Start implementing resource-centric layout. Lots of layout changes cascading everywhere. Support PUT and GET.

data/bootstrap/rsrc_centric_layout.nq

@@ -0,0 +1,7 @@
+<info:fcres/> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/ns/ldp#RDFSource> <info:fcsystem/__root__> .
+<info:fcres/> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/ns/ldp#Container> <info:fcsystem/__root__> .
+<info:fcres/> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/ns/ldp#BasicContainer> <info:fcsystem/__root__> .
+<info:fcres/> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://fedora.info/definitions/v4/repository#RepositoryRoot> <info:fcsystem/__root__> .
+<info:fcres/> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://fedora.info/definitions/v4/repository#Resource> <info:fcsystem/__root__> .
+<info:fcres/> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://fedora.info/definitions/v4/repository#Container> <info:fcsystem/__root__> .
+

data/bootstrap/rsrc_centric_layout.trig

@@ -0,0 +1,12 @@
+PREFIX fcrepo: <http://fedora.info/definitions/v4/repository#>
+PREFIX ldp: <http://www.w3.org/ns/ldp#>
+
+<info:fcsystem/meta> {
+}
+
+<info:fcsystem/__root__> {
+    <info:fcres/> a
+        fcrepo:RepositoryRoot , fcrepo:Resource , fcrepo:Container ,
+        ldp:Container , ldp:BasicContainer , ldp:RDFSource ;
+    .
+}

doc/examples/store_layouts/resource_centric.trig

@@ -0,0 +1,115 @@
+# Resource-centric layout. This separates resources into separate named
+# graphs and follows the graph-per-resource pattern
+# (http://patterns.dataincubator.org/book/graph-per-resource.html). This aligns
+# quite well with the resource-centrism of LDP and of the SPARQL Graph Store
+# Protocol (https://www.w3.org/TR/sparql11-http-rdf-update/) which should be
+# used by the software implementation to minimize data structure translation.
+#
+# A graph identified by the resource UID is the current state of that resource.
+# Other resources (graphs) can be present representing various previous states
+# of the resource and are identified by the resource UUID with a `:` (colon)
+# and the version UID appended.
+# E.g. a resource with a UID of `a/b/c` will be internally stored within a
+# named graph `info:fcstate/a/b/c`; the subject will be `info:fcres/a/b/c`;
+# a previous version could be `info:fcstate/a/b/c:version1` and the publicly
+# exposed URL could be http://webroot.org/ldp/a/b/c`.
+#
+# The relationships between resources and thir versions and other metadata not
+# meant to be directly exposed by the LDP API are in one "metadata" graph.
+
+PREFIX dc: <http://purl.org/dc/elements/1.1/>
+PREFIX fcrepo: <http://fedora.info/definitions/v4/repository#>
+PREFIX fcsystem: <info:fcsystem/>
+PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+PREFIX ldp: <http://www.w3.org/ns/ldp#>
+PREFIX ns: <http://example.edu/lakesuperior/ns#>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+
+# Metadata graph. This is a companion of the content graph.
+fcsystem:meta {
+  <info:fcstate/a/b/c> a fcrepo:Resource ;
+    # This may be redundant if we use naming conventions, but still good LD practice.
+    fcsystem:currentStateOf <info:fcres/a/b/c> ;
+    fcsystem:hasVersion
+      <info:fcstate/a/b/c:v1> , <info:fcstate/a/b/c:v2> , <info:fcstate/a/b/c:v3> ;
+  .
+
+  <info:fcstate/a/b/c:v1> a fcrepo:Version ;
+    fcrepo:created "2017-12-24T20:57:51.952535+00:00"^^xsd:dateTime .
+
+  <info:fcstate/a/b/c:v2> a fcrepo:Version ;
+    fcrepo:created "2017-12-25T20:57:51.952535+00:00"^^xsd:dateTime .
+
+  <info:fcstate/a/b/c:v3> a fcrepo:Version ;
+    fcrepo:created "2017-12-26T20:57:51.952535+00:00"^^xsd:dateTime .
+
+  # Pairtree information not passed to the client but used to mimic
+  # hierarchical structures.
+  <info:fcstate/a>
+    a fcrepo:Pairtree ;
+    fcsystem:contains <info:fcres/a/b> ;
+  .
+
+  <info:fcstate/a/b>
+    a fcrepo:Pairtree ;
+    fcsystem:contains <info:fcres/a/b/c> ;
+  .
+
+}
+
+# System root. It cannot be deleted.
+fcsystem:root {
+    fcsystem:root a
+        fcrepo:RepositoryRoot , fcrepo:Resource , fcrepo:Container ,
+        ldp:Container , ldp:BasicContainer , ldp:RDFSource ;
+    .
+}
+
+# Resource graph. These statements are returned to the client.
+# Note that "fragments"  or hash URIs are stored within the same graph.
+<info:fcstate/a/b/c> {
+  <info:fcres/a/b/c> a ns:Book ;
+    fcrepo:hasParent <info:fcres/a> ;
+    dc:title "Moby Dick" ;
+    dc:creator "Herman Melville" ;
+    dc:subject "Fishing" ;
+    .
+
+  <info:fcres/a/b/c#chapter1> a ns:BookChapter ;
+    dc:title "Loomings." ;
+    .
+
+  <info:fcres/a/b/c#chapter2> a ns:BookChapter ;
+    dc:title "The Carpet-Bag." ;
+    .
+}
+
+# Previous states (versions) of a resource.
+<info:fcstate/a/b/c:v1> {
+  <info:fcres/a/b/c> a ns:Book ;
+    fcrepo:hasParent <info:fcres/a> ;
+    dc:title "Moby Dick" ;
+    .
+}
+
+<info:fcstate/a/b/c:v2> {
+  <info:fcres/a/b/c> a ns:Book ;
+    fcrepo:hasParent <info:fcres/a> ;
+    dc:title "Moby Dick" ;
+    dc:creator "Herman Melvil" ;
+    .
+}
+
+<info:fcstate/a/b/c:v3> {
+  <info:fcres/a/b/c> a ns:Book ;
+    fcrepo:hasParent <info:fcres/a> ;
+    dc:title "Moby Dick" ;
+    dc:creator "Herman Melville" ;
+    .
+}
+
+# Only the direct link to the LDP-contained resource is explicitly asserted.
+<info:fcstate/a> {
+  <info:fcres/a> a ldp:Container , ldp:BasicContainer , ldp:Resource , ldp:RDFSSource ;
+    ldp:contains <info:fcres/a/b/c> .
+}

lakesuperior/dictionaries/namespaces.py

@@ -20,9 +20,10 @@ core_namespaces = {
     'rdf' : rdflib.namespace.RDF,
     'rdfs' : rdflib.namespace.RDFS,
     # For info: vs. urn:, see https://tools.ietf.org/html/rfc4452#section-6.3
-    'fcg' : Namespace('info:fcgraph:'),
-    'fcres' : Namespace('info:fcres:'),
-    'fcsystem' : Namespace('info:fcsystem:'),
+    'fcres' : Namespace('info:fcres/'),
+    'fcmeta' : Namespace('info:fcmeta/'),
+    'fcstate' : Namespace('info:fcstate/'),
+    'fcsystem' : Namespace('info:fcsystem/'),
     'webac' : Namespace('http://www.w3.org/ns/auth/acl#'),
     'xml' : Namespace('http://www.w3.org/XML/1998/namespace'),
     'xsd' : rdflib.namespace.XSD,
@@ -33,8 +34,9 @@ ns_collection = core_namespaces.copy()
 ns_collection.update(config['namespaces'])
 
 ns_mgr = NamespaceManager(Graph())
-ns_pfx_sparql = dict()
+ns_pfx_sparql = {}
 
 # Collection of prefixes in a dict.
 for ns,uri in ns_collection.items():
     ns_mgr.bind(ns, uri, override=False)
+    #ns_pfx_sparql[ns] = 'PREFIX {}: <{}>'.format(ns, uri)

lakesuperior/endpoints/ldp.py

@@ -99,14 +99,15 @@ def log_request_end(rsp):
 ## REST SERVICES ##
 
 @ldp.route('/<path:uuid>', methods=['GET'], strict_slashes=False)
-@ldp.route('/', defaults={'uuid': None}, methods=['GET'], strict_slashes=False)
+@ldp.route('/', defaults={'uuid': ''}, methods=['GET'], strict_slashes=False)
 @ldp.route('/<path:uuid>/fcr:metadata', defaults={'force_rdf' : True},
         methods=['GET'])
 def get_resource(uuid, force_rdf=False):
     '''
     Retrieve RDF or binary content.
 
-    @param uuid (string) UUID of resource to retrieve.
+    @param uuid (string) UID of resource to retrieve. The repository root has
+    an empty string for UID.
     @param force_rdf (boolean) Whether to retrieve RDF even if the resource is
     a LDP-NR. This is not available in the API but is used e.g. by the
     `*/fcr:metadata` endpoint. The default is False.

lakesuperior/model/ldp_factory.py

@@ -35,16 +35,16 @@ class LdpFactory:
 
         N.B. The resource must exist.
 
-        @param uuid UUID of the instance.
+        @param uuid UID of the instance.
         '''
         #__class__._logger.info('Retrieving stored resource: {}'.format(uuid))
         imr_urn = nsc['fcres'][uuid] if uuid else (
-                model.ldpr.Ldpr.ROOT_NODE_URN)
+                model.ldpr.ROOT_RSRC_URI)
 
-        imr = current_app.rdfly.extract_imr(imr_urn, **repr_opts)
+        imr = current_app.rdfly.extract_imr(uuid, **repr_opts)
         #__class__._logger.debug('Extracted graph: {}'.format(
         #        pformat(set(imr.graph))))
-        rdf_types = set(imr.graph.objects(imr.identifier, RDF.type))
+        rdf_types = set(imr.graph.objects(imr_urn, RDF.type))
 
         if __class__.LDP_NR_TYPE in rdf_types:
             __class__._logger.info('Resource is a LDP-NR.')

lakesuperior/model/ldp_rs.py

@@ -80,7 +80,7 @@ class LdpRs(Ldpr):
         #self._logger.debug('Provided SPARQL query: {}'.format(q))
         pre_gr = self.imr.graph
 
-        post_gr = deepcopy(pre_gr)
+        post_gr = pre_g | Graph()
         post_gr.update(q)
 
         remove_gr, add_gr = self._dedup_deltas(pre_gr, post_gr)

lakesuperior/model/ldpr.py

@@ -21,6 +21,11 @@ from lakesuperior.exceptions import *
 from lakesuperior.model.ldp_factory import LdpFactory
 
 
+ROOT_UID = ''
+ROOT_GRAPH_URI = nsc['fcsystem']['__root__']
+ROOT_RSRC_URI = nsc['fcres'][ROOT_UID]
+
+
 def atomic(fn):
     '''
     Handle atomic operations in an RDF store.
@@ -39,6 +44,7 @@ def atomic(fn):
             raise
         else:
             self._logger.info('Committing transaction.')
+            self.rdfly.optimize_edits()
             self.rdfly.store.commit()
             for ev in request.changelog:
                 #self._logger.info('Message: {}'.format(pformat(ev)))
@@ -48,7 +54,6 @@ def atomic(fn):
     return wrapper
 
 
-
 class Ldpr(metaclass=ABCMeta):
     '''LDPR (LDP Resource).
 
@@ -83,7 +88,6 @@ class Ldpr(metaclass=ABCMeta):
     RETURN_CHILD_RES_URI = nsc['fcrepo'].Children
     RETURN_INBOUND_REF_URI = nsc['fcrepo'].InboundReferences
     RETURN_SRV_MGD_RES_URI = nsc['fcrepo'].ServerManaged
-    ROOT_NODE_URN = nsc['fcsystem'].root
 
     # Workflow type. Inbound means that the resource is being written to the
     # store, outbounnd is being retrieved for output.
@@ -137,7 +141,7 @@ class Ldpr(metaclass=ABCMeta):
         self.uuid = g.tbox.uri_to_uuid(uuid) \
                 if isinstance(uuid, URIRef) else uuid
         self.urn = nsc['fcres'][uuid] \
-                if self.uuid else self.ROOT_NODE_URN
+                if self.uuid else ROOT_RSRC_URI
         self.uri = g.tbox.uuid_to_uri(self.uuid)
 
         self.rdfly = current_app.rdfly
@@ -177,7 +181,7 @@ class Ldpr(metaclass=ABCMeta):
             else:
                 imr_options = {}
             options = dict(imr_options, strict=True)
-            self._imr = self.rdfly.extract_imr(self.urn, **options)
+            self._imr = self.rdfly.extract_imr(self.uuid, **options)
 
         return self._imr
 
@@ -205,6 +209,27 @@ class Ldpr(metaclass=ABCMeta):
         delattr(self, '_imr')
 
 
+    @property
+    def metadata(self):
+        '''
+        Get resource metadata.
+        '''
+        if not hasattr(self, '_metadata'):
+            self._metadata = self.rdfly.get_metadata(self.uuid)
+
+        return self._metadata
+
+
+    @metadata.setter
+    def metadata(self, rsrc):
+        '''
+        Set resource metadata.
+        '''
+        if not isinstance(rsrc, Resource):
+            raise TypeError('Provided metadata is not a Resource object.')
+        self._metadata = rsrc
+
+
     @property
     def stored_or_new_imr(self):
         '''
@@ -223,7 +248,7 @@ class Ldpr(metaclass=ABCMeta):
                 imr_options = {}
             options = dict(imr_options, strict=True)
             try:
-                self._imr = self.rdfly.extract_imr(self.urn, **options)
+                self._imr = self.rdfly.extract_imr(self.uuid, **options)
             except ResourceNotExistsError:
                 self._imr = Resource(Graph(), self.urn)
                 for t in self.base_types:
@@ -302,7 +327,7 @@ class Ldpr(metaclass=ABCMeta):
             if hasattr(self, '_imr'):
                 self._is_stored = len(self.imr.graph) > 0
             else:
-                self._is_stored = self.rdfly.ask_rsrc_exists(self.urn)
+                self._is_stored = self.rdfly.ask_rsrc_exists(self.uuid)
 
         return self._is_stored
 
@@ -314,11 +339,13 @@ class Ldpr(metaclass=ABCMeta):
         @return set(rdflib.term.URIRef)
         '''
         if not hasattr(self, '_types'):
-            if hasattr(self, 'imr') and len(self.imr.graph):
+            if hasattr(self, '_imr') and len(self.imr.graph):
                 imr = self.imr
             elif hasattr(self, 'provided_imr') and \
                     len(self.provided_imr.graph):
-                imr = provided_imr
+                imr = self.provided_imr
+            else:
+                return set()
 
             self._types = set(imr.graph[self.urn : RDF.type])
 
@@ -345,12 +372,12 @@ class Ldpr(metaclass=ABCMeta):
         '''
         out_headers = defaultdict(list)
 
-        digest = self.imr.value(nsc['premis'].hasMessageDigest)
+        digest = self.metadata.value(nsc['premis'].hasMessageDigest)
         if digest:
             etag = digest.identifier.split(':')[-1]
             out_headers['ETag'] = 'W/"{}"'.format(etag),
 
-        last_updated_term = self.imr.value(nsc['fcrepo'].lastModified)
+        last_updated_term = self.metadata.value(nsc['fcrepo'].lastModified)
         if last_updated_term:
             out_headers['Last-Modified'] = arrow.get(last_updated_term)\
                 .format('ddd, D MMM YYYY HH:mm:ss Z')
@@ -433,7 +460,7 @@ class Ldpr(metaclass=ABCMeta):
 
         @EXPERIMENTAL
         '''
-        tstone_trp = set(self.rdfly.extract_imr(self.urn, strict=False).graph)
+        tstone_trp = set(self.rdfly.extract_imr(self.uuid, strict=False).graph)
 
         ver_rsp = self.version_info.query('''
         SELECT ?uid {
@@ -551,20 +578,19 @@ class Ldpr(metaclass=ABCMeta):
         '''
         create = create_only or not self.is_stored
 
-        self._add_srv_mgd_triples(create)
-        self._ensure_single_subject_rdf(self.provided_imr.graph)
+        self.metadata = self._srv_mgd_triples(create)
+        #self._ensure_single_subject_rdf(self.provided_imr.graph)
         ref_int = self.rdfly.config['referential_integrity']
         if ref_int:
             self._check_ref_int(ref_int)
 
-        if create:
-            ev_type = self._create_rsrc()
-        else:
-            ev_type = self._replace_rsrc()
+        import pdb; pdb.set_trace()
+        self.rdfly.create_or_replace_rsrc(self.uuid, self.provided_imr.graph,
+                self.metadata.graph)
 
         self._set_containment_rel()
 
-        return ev_type
+        return self.RES_CREATED if create else self.RES_UPDATED
 
 
     def _create_rsrc(self):
@@ -575,7 +601,7 @@ class Ldpr(metaclass=ABCMeta):
         self._modify_rsrc(self.RES_CREATED, add_trp=self.provided_imr.graph)
 
         # Set the IMR contents to the "add" triples.
-        self.imr = self.provided_imr.graph
+        #self.imr = self.provided_imr.graph
 
         return self.RES_CREATED
 
@@ -595,7 +621,7 @@ class Ldpr(metaclass=ABCMeta):
         self._modify_rsrc(self.RES_UPDATED, *delta)
 
         # Set the IMR contents to the "add" triples.
-        self.imr = delta[1]
+        #self.imr = delta[1]
 
         return self.RES_UPDATED
 
@@ -639,15 +665,16 @@ class Ldpr(metaclass=ABCMeta):
         '''
         self._logger.info('Purging resource {}'.format(self.urn))
         imr = self.rdfly.extract_imr(
-                self.urn, incl_inbound=True, strict=False)
+                self.uuid, incl_inbound=True, strict=False)
 
         # Remove resource itself.
-        self.rdfly.modify_dataset({(self.urn, None, None)}, types=None)
+        self.rdfly.modify_dataset(self.uuid, {(self.urn, None, None)}, types=None)
 
         # Remove fragments.
         for frag_urn in imr.graph[
                 : nsc['fcsystem'].fragmentOf : self.urn]:
-            self.rdfly.modify_dataset({(frag_urn, None, None)}, types={})
+            self.rdfly.modify_dataset(
+                    self.uuid, {(frag_urn, None, None)}, types={})
 
         # Remove snapshots.
         for snap_urn in self.versions:
@@ -655,7 +682,7 @@ class Ldpr(metaclass=ABCMeta):
                 (snap_urn, None, None),
                 (None, None, snap_urn),
             }
-            self.rdfly.modify_dataset(remove_trp, types={})
+            self.rdfly.modify_dataset(self.uuid, remove_trp, types={})
 
         # Remove inbound references.
         if inbound:
@@ -698,7 +725,7 @@ class Ldpr(metaclass=ABCMeta):
                         t[1], t[2]))
 
         self.rdfly.modify_dataset(
-                add_trp=ver_add_gr, types={nsc['fcrepo'].Version})
+                self.uuid, add_trp=ver_add_gr, types={nsc['fcrepo'].Version})
 
         # Add version metadata.
         meta_add_gr = Graph()
@@ -710,7 +737,7 @@ class Ldpr(metaclass=ABCMeta):
                 (ver_urn, nsc['fcrepo'].hasVersionLabel, Literal(ver_uid)))
 
         self.rdfly.modify_dataset(
-                add_trp=meta_add_gr, types={nsc['fcrepo'].Metadata})
+                self.uuid, add_trp=meta_add_gr, types={nsc['fcrepo'].Metadata})
 
         # Update resource.
         rsrc_add_gr = Graph()
@@ -722,8 +749,8 @@ class Ldpr(metaclass=ABCMeta):
         return nsc['fcres'][ver_uuid]
 
 
-    def _modify_rsrc(self, ev_type, remove_trp=Graph(), add_trp=Graph(),
-                     notify=True):
+    def _modify_rsrc(self, ev_type, remove_trp=set(), add_trp=set(),
+             remove_meta=set(), add_meta=set(), notify=True):
         '''
         Low-level method to modify a graph for a single resource.
 
@@ -732,27 +759,21 @@ class Ldpr(metaclass=ABCMeta):
         method.
 
         @param ev_type (string) The type of event (create, update, delete).
-        @param remove_trp (rdflib.Graph) Triples to be removed.
-        @param add_trp (rdflib.Graph) Triples to be added.
-        '''
-        # If one of the triple sets is not a graph, do a set merge and
-        # filtering. This is necessary to support non-RDF terms (e.g.
-        # variables).
-        if not isinstance(remove_trp, Graph) or not isinstance(add_trp, Graph):
-            if isinstance(remove_trp, Graph):
-                remove_trp = set(remove_trp)
-            if isinstance(add_trp, Graph):
-                add_trp = set(add_trp)
-            merge_gr = remove_trp | add_trp
-            type = { trp[2] for trp in merge_gr if trp[1] == RDF.type }
-            actor = { trp[2] for trp in merge_gr \
-                    if trp[1] == nsc['fcrepo'].createdBy }
-        else:
-            merge_gr = remove_trp | add_trp
-            type = merge_gr[self.urn : RDF.type]
-            actor = merge_gr[self.urn : nsc['fcrepo'].createdBy]
+        @param remove_trp (set) Triples to be removed.
+        @param add_trp (set) Triples to be added.
+        @param remove_meta (set) Metadata triples to be removed.
+        @param add_meta (set) Metadata triples to be added.
+        @param notify (boolean) Whether to send a message about the change.
+        '''
+        #for trp in [remove_trp, add_trp, remove_meta, add_meta]:
+        #    if not isinstance(trp, set):
+        #        trp = set(trp)
 
-        ret = self.rdfly.modify_dataset(remove_trp, add_trp)
+        type = self.types
+        actor = self.metadata.value(nsc['fcrepo'].createdBy)
+
+        ret = self.rdfly.modify_dataset(self.uuid, remove_trp, add_trp,
+                remove_meta, add_meta)
 
         if notify and current_app.config.get('messaging'):
             request.changelog.append((set(remove_trp), set(add_trp), {
@@ -838,28 +859,36 @@ class Ldpr(metaclass=ABCMeta):
         return gr
 
 
-    def _add_srv_mgd_triples(self, create=False):
+    def _srv_mgd_triples(self, create=False):
         '''
         Add server-managed triples to a provided IMR.
 
         @param create (boolean) Whether the resource is being created.
         '''
+        metadata = Resource(Graph(), self.urn)
         # Base LDP types.
         for t in self.base_types:
-            self.provided_imr.add(RDF.type, t)
+            metadata.add(RDF.type, t)
 
         # Message digest.
         cksum = g.tbox.rdf_cksum(self.provided_imr.graph)
-        self.provided_imr.set(nsc['premis'].hasMessageDigest,
+        metadata.set(nsc['premis'].hasMessageDigest,
                 URIRef('urn:sha1:{}'.format(cksum)))
 
         # Create and modify timestamp.
         if create:
-            self.provided_imr.set(nsc['fcrepo'].created, g.timestamp_term)
-            self.provided_imr.set(nsc['fcrepo'].createdBy, self.DEFAULT_USER)
+            metadata.set(nsc['fcrepo'].created, g.timestamp_term)
+            metadata.set(nsc['fcrepo'].createdBy, self.DEFAULT_USER)
+        else:
+            metadata.set(nsc['fcrepo'].created, self.metadata.value(
+                    nsc['fcrepo'].created))
+            metadata.set(nsc['fcrepo'].createdBy, self.metadata.value(
+                    nsc['fcrepo'].createdBy))
+
+        metadata.set(nsc['fcrepo'].lastModified, g.timestamp_term)
+        metadata.set(nsc['fcrepo'].lastModifiedBy, self.DEFAULT_USER)
 
-        self.provided_imr.set(nsc['fcrepo'].lastModified, g.timestamp_term)
-        self.provided_imr.set(nsc['fcrepo'].lastModifiedBy, self.DEFAULT_USER)
+        return metadata
 
 
     def _set_containment_rel(self):
@@ -871,18 +900,18 @@ class Ldpr(metaclass=ABCMeta):
           pairtree nodes are created for a/b and a/b/c.
         - If e is being created, the root node becomes container of e.
         '''
-        if self.urn == self.ROOT_NODE_URN:
+        if self.urn == ROOT_RSRC_URI:
             return
         elif '/' in self.uuid:
             # Traverse up the hierarchy to find the parent.
-            parent_uri = self._find_parent_or_create_pairtree()
+            parent_uid = self._find_parent_or_create_pairtree()
         else:
-            parent_uri = self.ROOT_NODE_URN
+            parent_uid = ROOT_UID
 
         add_gr = Graph()
-        add_gr.add((parent_uri, nsc['ldp'].contains, self.urn))
+        add_gr.add((nsc['fcres'][parent_uid], nsc['ldp'].contains, self.urn))
         parent_rsrc = LdpFactory.from_stored(
-                g.tbox.uri_to_uuid(parent_uri), repr_opts={
+                parent_uid, repr_opts={
                 'incl_children' : False}, handling='none')
         parent_rsrc._modify_rsrc(self.RES_UPDATED, add_trp=add_gr)
 
@@ -893,16 +922,16 @@ class Ldpr(metaclass=ABCMeta):
     def _find_parent_or_create_pairtree(self):
         '''
         Check the path-wise parent of the new resource. If it exists, return
-        its URI. Otherwise, create pairtree resources up the path until an
+        its UID. Otherwise, create pairtree resources up the path until an
         actual resource or the root node is found.
 
-        @return rdflib.term.URIRef
+        @return string Resource UID.
         '''
         path_components = self.uuid.split('/')
 
-         # If there is only on element, the parent is the root node.
+         # If there is only one element, the parent is the root node.
         if len(path_components) < 2:
-            return self.ROOT_NODE_URN
+            return ROOT_UID
 
         # Build search list, e.g. for a/b/c/d/e would be a/b/c/d, a/b/c, a/b, a
         self._logger.info('Path components: {}'.format(path_components))
@@ -912,26 +941,23 @@ class Ldpr(metaclass=ABCMeta):
         )
         rev_search_order = reversed(list(fwd_search_order))
 
-        cur_child_uri = nsc['fcres'][self.uuid]
-        parent_uri = None
+        cur_child_uid = self.uuid
+        parent_uid = ROOT_UID # Defaults to root
         segments = []
-        for cparent_uuid in rev_search_order:
-            cparent_uri = nsc['fcres'][cparent_uuid]
+        for cparent_uid in rev_search_order:
+            cparent_uid = cparent_uid
 
-            if self.rdfly.ask_rsrc_exists(cparent_uri):
-                parent_uri = cparent_uri
+            if self.rdfly.ask_rsrc_exists(cparent_uid):
+                parent_uid = cparent_uid
                 break
             else:
-                segments.append((cparent_uri, cur_child_uri))
-                cur_child_uri = cparent_uri
+                segments.append((cparent_uid, cur_child_uid))
+                cur_child_uid = cparent_uid
 
-        if parent_uri is None:
-            parent_uri = self.ROOT_NODE_URN
+        for uid, child_uid in segments:
+            self._create_path_segment(uid, child_uid, parent_uid)
 
-        for uri, child_uri in segments:
-            self._create_path_segment(uri, child_uri, parent_uri)
-
-        return parent_uri
+        return parent_uid
 
 
     def _dedup_deltas(self, remove_gr, add_gr):
@@ -945,32 +971,30 @@ class Ldpr(metaclass=ABCMeta):
         )
 
 
-    def _create_path_segment(self, uri, child_uri, real_parent_uri):
+    def _create_path_segment(self, uid, child_uid, real_parent_uid):
         '''
         Create a path segment with a non-LDP containment statement.
 
-        This diverges from the default fcrepo4 behavior which creates pairtree
-        resources.
-
         If a resource such as `fcres:a/b/c` is created, and neither fcres:a or
         fcres:a/b exists, we have to create two "hidden" containment statements
         between a and a/b and between a/b and a/b/c in order to maintain the
         `containment chain.
         '''
-        imr = Resource(Graph(), uri)
+        imr = Resource(Graph(), nsc['fcres'][uid])
         imr.add(RDF.type, nsc['ldp'].Container)
         imr.add(RDF.type, nsc['ldp'].BasicContainer)
         imr.add(RDF.type, nsc['ldp'].RDFSource)
         imr.add(RDF.type, nsc['fcrepo'].Pairtree)
-        imr.add(nsc['fcrepo'].contains, child_uri)
+        imr.add(nsc['fcrepo'].contains, nsc['fcres'][child_uid])
         imr.add(nsc['ldp'].contains, self.urn)
-        imr.add(nsc['fcrepo'].hasParent, real_parent_uri)
+        imr.add(nsc['fcrepo'].hasParent, nsc['fcres'][real_parent_uid])
 
         # If the path segment is just below root
-        if '/' not in str(uri):
-            imr.graph.add((nsc['fcsystem'].root, nsc['fcrepo'].contains, uri))
+        if '/' not in uid:
+            imr.graph.addN((nsc['fcsystem'].root, nsc['fcrepo'].contains,
+                    nsc['fcres'][uid], ROOT_GRAPH_URI))
 
-        self.rdfly.modify_dataset(add_trp=imr.graph)
+        self.rdfly.modify_dataset(self.uuid, add_trp=imr.graph)
 
 
     def _add_ldp_dc_ic_rel(self, cont_rsrc):

lakesuperior/store_layouts/ldp_rs/base_connector.py

@@ -70,7 +70,7 @@ class BaseConnector(metaclass=ABCMeta):
         #    q, initBindings))
         #self._logger.debug('From:\n{}'.format(
         #    (''.join(traceback.format_stack(limit=5)))))
-        return self.ds.query(q, initBindings=initBindings, initNs=nsc)
+        return self.ds.query(q, initBindings=initBindings)
 
 
 

lakesuperior/store_layouts/ldp_rs/base_rdf_layout.py

@@ -67,7 +67,7 @@ class BaseRdfLayout(metaclass=ABCMeta):
         self._conn = conn
         self.store = self._conn.store
 
-        self.UNION_GRAPH_URI = self._conn.UNION_GRAPH_URI
+        #self.UNION_GRAPH_URI = self._conn.UNION_GRAPH_URI
         self.ds = self._conn.ds
         self.ds.namespace_manager = nsm
 
@@ -106,7 +106,7 @@ class BaseRdfLayout(metaclass=ABCMeta):
         pass
 
 
-    @abstractmethod
+    #@abstractmethod
     def get_version_info(self, urn):
         '''
         Get version information about a resource (`fcr:versions`)
@@ -114,7 +114,7 @@ class BaseRdfLayout(metaclass=ABCMeta):
         pass
 
 
-    @abstractmethod
+    #@abstractmethod
     def get_version(self, urn):
         '''
         Get a historic snapshot (version) of a resource.
@@ -135,7 +135,7 @@ class BaseRdfLayout(metaclass=ABCMeta):
         pass
 
 
-    @abstractmethod
+    #@abstractmethod
     def modify_dataset(self, remove_trp=Graph(), add_trp=Graph(),
             types=set()):
         '''

lakesuperior/store_layouts/ldp_rs/rsrc_centric_layout.py

@@ -0,0 +1,259 @@
+import logging
+
+from copy import deepcopy
+from pprint import pformat
+from urllib.parse import quote
+
+import requests
+
+from flask import current_app
+from rdflib import Graph
+from rdflib.namespace import RDF
+from rdflib.query import ResultException
+from rdflib.resource import Resource
+from rdflib.term import URIRef
+
+from lakesuperior.dictionaries.namespaces import ns_collection as nsc
+from lakesuperior.dictionaries.namespaces import ns_mgr as nsm
+from lakesuperior.dictionaries.namespaces import ns_pfx_sparql
+from lakesuperior.exceptions import (InvalidResourceError, InvalidTripleError,
+        ResourceNotExistsError, TombstoneError)
+from lakesuperior.store_layouts.ldp_rs.base_rdf_layout import BaseRdfLayout
+from lakesuperior.model.ldpr import ROOT_UID, ROOT_GRAPH_URI, ROOT_RSRC_URI
+
+
+class RsrcCentricLayout(BaseRdfLayout):
+    '''
+    Resource-centric layout.
+
+    See http://patterns.dataincubator.org/book/graph-per-resource.html
+    This implementation places each resource and its fragments within a named
+    graph. Version snapshots are also stored in individual graphs and are named
+    related in a metadata graph.
+
+    This layout is best used not with a connector that uses RDFlib but rather
+    with one that employs a direct interaction with the Graph Store Protocol,
+    either via HTTP or, ideally, using native API bindings.
+    '''
+    _logger = logging.getLogger(__name__)
+
+    META_GRAPH_URI = nsc['fcsystem'].meta
+
+    def bootstrap(self):
+        '''
+        Delete all graphs and insert the basic triples.
+        '''
+        #requests.post(self.UPDATE_LOC, data='DROP SILENT ALL', headers={
+        #    'content-type': 'application/sparql-update'})
+
+        self._logger.info('Deleting all data from the graph store.')
+        self.ds.update('DROP SILENT ALL')
+
+        self._logger.info('Initializing the graph store with system data.')
+        self.ds.default_context.parse(
+                source='data/bootstrap/rsrc_centric_layout.nq', format='nquads')
+        #with open('data/bootstrap/rsrc_centric_layout.nq', 'rb') as f:
+        #    requests.put(self.GRAPH_LOC, data=f, headers={
+        #        'content-type': 'application/n-quads'})
+        self.ds.store.close()
+
+
+    def extract_imr(
+                self, uid, ver_uid=None, strict=True, incl_inbound=False,
+                incl_children=True, embed_children=False, incl_srv_mgd=True):
+        '''
+        See base_rdf_layout.extract_imr.
+        '''
+        inbound_construct = '\n?s1 ?p1 ?s .' if incl_inbound else ''
+        inbound_qry = '''
+        OPTIONAL {
+          GRAPH ?g {
+            ?s1 ?p1 ?s .
+          }
+          GRAPH ?mg {
+            ?g a fcsystem:CurrentState .
+          }
+        }
+        ''' if incl_inbound else ''
+
+        # Include and/or embed children.
+        embed_children_trp = embed_children_qry = ''
+        if incl_srv_mgd and incl_children:
+            incl_children_qry = ''
+
+            # Embed children.
+            if embed_children:
+                embed_children_trp = '?c ?cp ?co .'
+                embed_children_qry = '''
+                OPTIONAL {{
+                  ?s ldp:contains ?c .
+                  {}
+                }}
+                '''.format(embed_children_trp)
+        else:
+            incl_children_qry = '\nFILTER ( ?p != ldp:contains )' \
+
+        q = '''
+        CONSTRUCT {{
+            ?meta_s ?meta_p ?meta_o .
+            ?s ?p ?o .{inb_cnst}
+            {embed_chld_t}
+            ?s fcrepo:writable true .
+        }}
+        WHERE {{
+          GRAPH ?mg {{
+            ?meta_s ?meta_p ?meta_o .
+          }}
+          OPTIONAL {{
+            GRAPH ?sg {{
+              ?s ?p ?o .{inb_qry}{incl_chld}{embed_chld}
+            }}
+          }}{inb_qry}
+        }}
+        '''.format(
+                inb_cnst=inbound_construct, inb_qry=inbound_qry,
+                incl_chld=incl_children_qry, embed_chld_t=embed_children_trp,
+                embed_chld=embed_children_qry,
+                )
+
+        mg = ROOT_GRAPH_URI if uid == '' else nsc['fcmeta'][uid]
+        try:
+            qres = self.store.query(q, initBindings={'mg': mg,
+                'sg': self._state_uri(uid, ver_uid)})
+        except ResultException:
+            # RDFlib bug: https://github.com/RDFLib/rdflib/issues/775
+            gr = Graph()
+        else:
+            gr = qres.graph
+
+        #self._logger.debug('Found resource: {}'.format(
+        #        gr.serialize(format='turtle').decode('utf-8')))
+        if strict and not len(gr):
+            raise ResourceNotExistsError(uid)
+
+        rsrc = Resource(gr, nsc['fcres'][uid])
+
+        # Check if resource is a tombstone.
+        if rsrc[RDF.type : nsc['fcsystem'].Tombstone]:
+            if strict:
+                raise TombstoneError(
+                        g.tbox.uri_to_uuid(rsrc.identifier),
+                        rsrc.value(nsc['fcrepo'].created))
+            else:
+                self._logger.info('Tombstone found: {}'.format(uid))
+        elif rsrc.value(nsc['fcsystem'].tombstone):
+            if strict:
+                raise TombstoneError(
+                        g.tbox.uri_to_uuid(
+                            rsrc.value(nsc['fcsystem'].tombstone).identifier),
+                        rsrc.value(nsc['fcrepo'].created))
+            else:
+                self._logger.info('Parent tombstone found: {}'.format(uri))
+
+        return rsrc
+
+
+    def ask_rsrc_exists(self, uid):
+        '''
+        See base_rdf_layout.ask_rsrc_exists.
+        '''
+        meta_gr = self.ds.graph(nsc['fcmeta'][uid])
+        return bool(
+                meta_gr[nsc['fcres'][uid] : RDF.type : nsc['fcrepo'].Resource])
+
+
+    def get_metadata(self, uid):
+        '''
+        See base_rdf_layout.get_version_info.
+        '''
+        gr_uri = ROOT_GRAPH_URI if uid == ROOT_UID else nsc['fcmeta'][uid]
+        meta_gr = self.ds.graph(gr_uri)
+
+        return Resource(meta_gr | Graph(), nsc['fcres'][uid])
+
+
+    def get_version(self, uid, ver_uid):
+        '''
+        See base_rdf_layout.get_version.
+        '''
+        # @TODO
+        gr = self.ds.graph(self._state_uri(uid, ver_uid))
+        return Resource(gr | Graph(), nsc['fcres'][uid])
+
+
+    def create_or_replace_rsrc(self, uid, data, metadata, ver_uid=None):
+        '''
+        Create a new resource or replace an existing one.
+        '''
+        sg_uri = self._state_uri(uid)
+        mg_uri = self._meta_uri(uid)
+        if ver_uid:
+            ver_uri = self._state_uri(uid, ver_uid)
+            drop_qry = 'MOVE SILENT {sg} TO {vg};\n'.format(
+                    sg=sg_uri.n3(), vg=ver_uri.n3())
+        else:
+            drop_qry = 'DROP SILENT GRAPH {};\n'.format(sg_uri.n3())
+        drop_qry += 'DROP SILENT GRAPH {}\n'.format(mg_uri.n3())
+
+        self.ds.update(drop_qry)
+
+        sg = self.ds.graph(sg_uri)
+        sg += data
+        mg = self.ds.graph(mg_uri)
+        mg += metadata
+
+
+    def modify_dataset(self, uid, remove_trp=set(), add_trp=set(),
+            remove_meta=set(), add_meta=set(), **kwargs):
+        '''
+        See base_rdf_layout.update_rsrc.
+        '''
+        gr = self.ds.graph(self._state_uri(uid))
+        if len(remove_trp):
+            gr -= remove_trp
+        if len(add_trp):
+            gr += add_trp
+
+        meta_gr = self.ds.graph(self._meta_uri(uid))
+        if len(remove_meta):
+            gr -= remove_meta
+        if len(add_meta):
+            gr += add_meta
+
+
+    ## PROTECTED MEMBERS ##
+
+    def _state_uri(self, uid, version_uid=None):
+        '''
+        Convert a UID into a request URL to the graph store.
+        '''
+        if not uid:
+            #raise InvalidResourceError(uid,
+            #        'Repository root does not accept user-defined properties.')
+            return ROOT_GRAPH_URI
+        if version_uid:
+            uid += ':' + version_uid
+        else:
+            return nsc['fcstate'][uid]
+
+
+    def _meta_uri(self, uid):
+        '''
+        Convert a UID into a request URL to the graph store.
+        '''
+        if not uid:
+            return ROOT_GRAPH_URI
+        else:
+            return nsc['fcmeta'][uid]
+
+
+    def optimize_edits(self):
+        opt_edits = [
+                l for l in self.store._edits
+                if not l.startswith('PREFIX')]
+        #opt_edits = list(ns_pfx_sparql.values()) + opt_edits
+        #import pdb; pdb.set_trace()
+        self.store._edits = opt_edits
+        self._logger.debug('Changes to be committed: {}'.format(
+            pformat(self.store._edits)))
+

lakesuperior/toolbox.py

@@ -6,9 +6,11 @@ from collections import defaultdict
 from hashlib import sha1
 
 from flask import g
+from rdflib import Graph
 from rdflib.term import URIRef, Variable
 
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
+from lakesuperior.model.ldpr import ROOT_GRAPH_URI, ROOT_RSRC_URI
 
 
 class Toolbox:
@@ -18,8 +20,6 @@ class Toolbox:
 
     _logger = logging.getLogger(__name__)
 
-    ROOT_NODE_URN = nsc['fcsystem'].root
-
     def replace_term_domain(self, term, search, replace):
         '''
         Replace the domain of a term.
@@ -52,7 +52,7 @@ class Toolbox:
 
         @return string
         '''
-        if uri == self.ROOT_NODE_URN:
+        if uri == ROOT_GRAPH_URI or uri == ROOT_RSRC_URI:
             return None
         elif uri.startswith(nsc['fcres']):
             return str(uri).replace(nsc['fcres'], '')
@@ -68,14 +68,14 @@ class Toolbox:
         @return string
         '''
         if s.strip('/') == g.webroot:
-            return str(self.ROOT_NODE_URN)
+            return str(ROOT_RSRC_URI)
         else:
             return s.strip('/').replace(g.webroot+'/', str(nsc['fcres']))
 
 
     def localize_term(self, uri):
         '''
-        Convert an URI into an URN.
+        Localize an individual term.
 
         @param rdflib.term.URIRef urn Input URI.
 
@@ -84,36 +84,32 @@ class Toolbox:
         return URIRef(self.localize_string(str(uri)))
 
 
+    def localize_triple(self, trp):
+        '''
+        Localize terms in a triple.
+
+        @param trp (tuple(rdflib.term.URIRef)) The triple to be converted
+
+        @return tuple(rdflib.term.URIRef)
+        '''
+        s, p, o = trp
+        if s.startswith(g.webroot):
+            s = self.localize_term(s)
+        if o.startswith(g.webroot):
+            o = self.localize_term(o)
+
+        return s, p, o
+
+
     def localize_graph(self, gr):
         '''
-        Locbalize a graph.
+        Localize a graph.
         '''
-        q = '''
-        CONSTRUCT {{ ?s ?p ?o . }} WHERE {{
-          {{
-            ?s ?p ?o .
-            FILTER (
-              STRSTARTS(str(?s), "{0}")
-              ||
-              STRSTARTS(str(?o), "{0}")
-              ||
-              STRSTARTS(str(?s), "{0}/")
-              ||
-              STRSTARTS(str(?o), "{0}/")
-            ) .
-          }}
-        }}'''.format(g.webroot)
-        flt_gr = gr.query(q)
-
-        for t in flt_gr:
-            local_s = self.localize_term(t[0])
-            local_o = self.localize_term(t[2]) \
-                    if isinstance(t[2], URIRef) \
-                    else t[2]
-            gr.remove(t)
-            gr.add((local_s, t[1], local_o))
-
-        return gr
+        l_gr = Graph()
+        for trp in gr:
+            l_gr.add(self.localize_triple(trp))
+
+        return l_gr
 
 
     def localize_ext_str(self, s, urn):
@@ -139,7 +135,7 @@ class Toolbox:
         s2 = re.sub(loc_ptn2, loc_sub2, s1)
 
         loc_ptn3 = r'<{}([#?].*?)?>'.format(nsc['fcres'])
-        loc_sub3 = '<{}\\1>'.format(self.ROOT_NODE_URN)
+        loc_sub3 = '<{}\\1>'.format(ROOT_RSRC_URI)
         s3 = re.sub(loc_ptn3, loc_sub3, s2)
 
         return s3
@@ -163,42 +159,38 @@ class Toolbox:
 
         @return rdflib.term.URIRef
         '''
-        if urn == self.ROOT_NODE_URN:
+        if urn == ROOT_RSRC_URI:
             urn = nsc['fcres']
 
         return URIRef(self.globalize_string(str(urn)))
 
 
+    def globalize_triple(self, trp):
+        '''
+        Globalize terms in a triple.
+
+        @param trp (tuple(rdflib.term.URIRef)) The triple to be converted
+
+        @return tuple(rdflib.term.URIRef)
+        '''
+        s, p, o = trp
+        if s.startswith(nsc['fcres']):
+            s = self.globalize_term(s)
+        if o.startswith(nsc['fcres']):
+            o = self.globalize_term(o)
+
+        return s, p, o
+
+
     def globalize_graph(self, gr):
         '''
         Globalize a graph.
         '''
-        q = '''
-        CONSTRUCT {{ ?s ?p ?o . }} WHERE {{
-          {{
-            ?s ?p ?o .
-            FILTER (
-              STRSTARTS(str(?s), "{0}")
-              ||
-              STRSTARTS(str(?o), "{0}")
-              ||
-              STRSTARTS(str(?s), "{1}")
-              ||
-              STRSTARTS(str(?o), "{1}")
-            ) .
-          }}
-        }}'''.format(nsc['fcres'], self.ROOT_NODE_URN)
-        flt_gr = gr.query(q)
-
-        for t in flt_gr:
-            global_s = self.globalize_term(t[0])
-            global_o = self.globalize_term(t[2]) \
-                    if isinstance(t[2], URIRef) \
-                    else t[2]
-            gr.remove(t)
-            gr.add((global_s, t[1], global_o))
-
-        return gr
+        g_gr = Graph()
+        for trp in gr:
+            g_gr.add(self.globalize_triple(trp))
+
+        return g_gr
 
 
     def globalize_rsrc(self, rsrc):
@@ -240,7 +232,6 @@ class Toolbox:
 
             for param_token in token_list:
                 # If the token list had a ';' the preference has a parameter.
-                print('Param token: {}'.format(param_token))
                 param_parts = [ prm.strip().strip('"') \
                         for prm in param_token.split('=') ]
                 param_value = param_parts[1] if len(param_parts) > 1 else None

profiler.py

@@ -6,7 +6,11 @@ from lakesuperior.config_parser import config
 
 fcrepo = create_app(config['application'], config['logging'])
 
-fcrepo.wsgi_app = ProfilerMiddleware(fcrepo.wsgi_app, restrictions=[30])
+options = {
+    'restrictions': [30],
+    'profile_dir': '/tmp/lsup_profiling'
+}
+fcrepo.wsgi_app = ProfilerMiddleware(fcrepo.wsgi_app, **options)
 fcrepo.config['PROFILE'] = True
 fcrepo.run(debug = True)
 

tests/10K_children.py

@@ -32,15 +32,18 @@ ckpt = start
 print('Inserting {} children.'.format(n))
 
 data = open(datafile, 'rb').read()
-for i in range(1, n):
-    requests.put('{}/{}'.format(container, uuid4()), data=data, headers={
-        'content-type': 'text/turtle'})
-    if i % 100 == 0:
-        now = arrow.utcnow()
-        tdelta = now - ckpt
-        ckpt = now
-        print('Record: {}\tTime elapsed: {}'.format(i, tdelta))
+try:
+    for i in range(1, n):
+        requests.put('{}/{}'.format(container, uuid4()), data=data, headers={
+            'content-type': 'text/turtle'})
+        if i % 10 == 0:
+            now = arrow.utcnow()
+            tdelta = now - ckpt
+            ckpt = now
+            print('Record: {}\tTime elapsed: {}'.format(i, tdelta))
+except KeyboardInterrupt:
+    print('Interruped after {} iterations.'.format(i))
 
 tdelta = arrow.utcnow() - start
 print('Total elapsed time: {}'.format(tdelta))
-print('Average time per resource: {}'.format(tdelta.total_seconds()/n))
+print('Average time per resource: {}'.format(tdelta.total_seconds()/i))

tests/bdb.py

@@ -1,40 +1,52 @@
 #!/usr/bin/env python
 import sys
 
+from random import randrange
 from uuid import uuid4
 
 import arrow
 
 from rdflib import Dataset
+from rdflib import plugin
+from rdflib.store import Store
 from rdflib.term import URIRef
 
 default_n = 100000
 sys.stdout.write('How many resources? [{}] >'.format(default_n))
 choice = input().lower()
 n = int(choice) if choice else default_n
+store_uid = randrange(8192)
+store_name = '/tmp/lsup_{}.db'.format(store_uid)
 
-ds = Dataset('Sleepycat')
-ds.open('/tmp/lsup_bdb.db')
-gr = ds.graph('http://ex.org/graph#g1')
+store = plugin.get('Sleepycat', Store)()
+ds = Dataset(store)
+store.open(store_name)
 
 start = arrow.utcnow()
 ckpt = start
 
 for i in range(1, n):
-    if i % 100 == 0:
-        print('inserted {} resources.'.format(i))
-    subj = URIRef('http://ex.org/rdf/{}'.format(uuid4()))
-    gr.add((subj, URIRef('http://ex.org/p1'), URIRef('http://ex.org/o1')))
-    gr.add((URIRef('http://ex.org/s1'), URIRef('http://ex.org/p2'), subj))
-
-    now = arrow.utcnow()
-    tdelta = now - ckpt
-    ckpt = now
-    print('Record: {}\tTime elapsed: {}'.format(i, tdelta))
+    try:
+        subj = URIRef('http://ex.org/rdf/{}'.format(uuid4()))
+        gr = ds.graph('http://ex.org/graph#g{}'.format(i))
+        for ii in range(1, 100):
+            gr.add((subj, URIRef('http://ex.org/p1'),
+                URIRef('http://ex.org/random#'.format(randrange(2048)))))
+        gr.add((URIRef('http://ex.org/s1'), URIRef('http://ex.org/p2'), subj))
+
+        now = arrow.utcnow()
+        tdelta = now - ckpt
+        ckpt = now
+        if i % 100 == 0:
+            print('Record: {}\tTime elapsed: {}'.format(i, tdelta))
+    except KeyboardInterrupt:
+        print('Interrupted after {} iterations.'.format(i))
+        break
 
 tdelta = arrow.utcnow() - start
+print('Store name: {}'.format(store_name))
 print('Total elapsed time: {}'.format(tdelta))
-print('Average time per resource: {}'.format(tdelta.total_seconds()/n))
+print('Average time per resource: {}'.format(tdelta.total_seconds()/i))
 print('Graph size: {}'.format(len(gr)))
 
-ds.close()
+store.close()

util/bootstrap.py

@@ -20,26 +20,6 @@ Additional, scaffolding files may be parsed to create initial contents.
 '''
 
 
-def bootstrap_db(app):
-    '''
-    Initialize RDF store.
-    '''
-    print('Cleaning up graph store: {}'.format(
-            app.config['store']['ldp_rs']['connector']['options']['location']))
-    for g in app.rdfly.ds.graphs():
-        app.rdfly.ds.remove_graph(g)
-
-    # @TODO Make configurable.
-    print('Populating graph store with base dataset.')
-    app.rdfly.ds.default_context.parse(
-            source='data/bootstrap/default_layout.nq', format='nquads')
-
-    app.rdfly.ds.store.commit()
-    app.rdfly.ds.close()
-
-    return app.rdfly
-
-
 def bootstrap_binary_store(app):
     '''
     Initialize binary file store.
@@ -65,5 +45,5 @@ if __name__=='__main__':
         sys.exit()
 
     app = create_app(config['application'], config['logging'])
-    bootstrap_db(app)
+    app.rdfly.bootstrap()
     bootstrap_binary_store(app)