Optimize operations for PUT.

lakesuperior/endpoints/ldp.py

@@ -98,15 +98,15 @@ def log_request_end(rsp):
 
 ## REST SERVICES ##
 
-@ldp.route('/<path:uuid>', methods=['GET'], strict_slashes=False)
-@ldp.route('/', defaults={'uuid': ''}, methods=['GET'], strict_slashes=False)
-@ldp.route('/<path:uuid>/fcr:metadata', defaults={'force_rdf' : True},
+@ldp.route('/<path:uid>', methods=['GET'], strict_slashes=False)
+@ldp.route('/', defaults={'uid': ''}, methods=['GET'], strict_slashes=False)
+@ldp.route('/<path:uid>/fcr:metadata', defaults={'force_rdf' : True},
         methods=['GET'])
-def get_resource(uuid, force_rdf=False):
+def get_resource(uid, force_rdf=False):
     '''
     Retrieve RDF or binary content.
 
-    @param uuid (string) UID of resource to retrieve. The repository root has
+    @param uid (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
@@ -121,11 +121,11 @@ def get_resource(uuid, force_rdf=False):
             repr_options = parse_repr_options(prefer['return'])
 
     try:
-        rsrc = LdpFactory.from_stored(uuid, repr_options)
+        rsrc = LdpFactory.from_stored(uid, repr_options)
     except ResourceNotExistsError as e:
         return str(e), 404
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
     else:
         out_headers.update(rsrc.head())
         if isinstance(rsrc, LdpRs) \
@@ -169,9 +169,9 @@ def post_resource(parent):
     stream, mimetype = bitstream_from_req()
 
     try:
-        uuid = uuid_for_post(parent, slug)
-        logger.debug('Generated UUID for POST: {}'.format(uuid))
-        rsrc = LdpFactory.from_provided(uuid, content_length=request.content_length,
+        uid = uuid_for_post(parent, slug)
+        logger.debug('Generated UID for POST: {}'.format(uid))
+        rsrc = LdpFactory.from_provided(uid, content_length=request.content_length,
                 stream=stream, mimetype=mimetype, handling=handling,
                 disposition=disposition)
     except ResourceNotExistsError as e:
@@ -179,7 +179,7 @@ def post_resource(parent):
     except InvalidResourceError as e:
         return str(e), 409
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
 
     try:
         rsrc.post()
@@ -199,87 +199,87 @@ def post_resource(parent):
     return rsrc.uri, 201, out_headers
 
 
-@ldp.route('/<path:uuid>/fcr:versions', methods=['GET'])
-def get_version_info(uuid):
+@ldp.route('/<path:uid>/fcr:versions', methods=['GET'])
+def get_version_info(uid):
     '''
     Get version info (`fcr:versions`).
     '''
     try:
-        rsp = Ldpr(uuid).get_version_info()
+        rsp = Ldpr(uid).get_version_info()
     except ResourceNotExistsError as e:
         return str(e), 404
     except InvalidResourceError as e:
         return str(e), 409
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
     else:
         return rsp.serialize(format='turtle'), 200
 
 
-@ldp.route('/<path:uuid>/fcr:versions/<ver_uid>', methods=['GET'])
-def get_version(uuid, ver_uid):
+@ldp.route('/<path:uid>/fcr:versions/<ver_uid>', methods=['GET'])
+def get_version(uid, ver_uid):
     '''
     Get an individual resource version.
 
-    @param uuid (string) Resource UUID.
+    @param uid (string) Resource UID.
     @param ver_uid (string) Version UID.
     '''
     try:
-        rsp = Ldpr(uuid).get_version(ver_uid)
+        rsp = Ldpr(uid).get_version(ver_uid)
     except ResourceNotExistsError as e:
         return str(e), 404
     except InvalidResourceError as e:
         return str(e), 409
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
     else:
         return rsp.serialize(format='turtle'), 200
 
 
-@ldp.route('/<path:uuid>/fcr:versions', methods=['POST'])
-def post_version(uuid):
+@ldp.route('/<path:uid>/fcr:versions', methods=['POST'])
+def post_version(uid):
     '''
     Create a new resource version.
     '''
     ver_uid = request.headers.get('slug', None)
     try:
-        ver_uri = LdpFactory.from_stored(uuid).create_version(ver_uid)
+        ver_uri = LdpFactory.from_stored(uid).create_version(ver_uid)
     except ResourceNotExistsError as e:
         return str(e), 404
     except InvalidResourceError as e:
         return str(e), 409
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
     else:
         return '', 201, {'Location': ver_uri}
 
 
-@ldp.route('/<path:uuid>/fcr:versions/<ver_uid>', methods=['PATCH'])
-def patch_version(uuid, ver_uid):
+@ldp.route('/<path:uid>/fcr:versions/<ver_uid>', methods=['PATCH'])
+def patch_version(uid, ver_uid):
     '''
     Revert to a previous version.
 
     NOTE: This creates a new version snapshot.
 
-    @param uuid (string) Resource UUID.
+    @param uid (string) Resource UID.
     @param ver_uid (string) Version UID.
     '''
     try:
-        LdpFactory.from_stored(uuid).revert_to_version(ver_uid)
+        LdpFactory.from_stored(uid).revert_to_version(ver_uid)
     except ResourceNotExistsError as e:
         return str(e), 404
     except InvalidResourceError as e:
         return str(e), 409
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
     else:
         return '', 204
 
 
-@ldp.route('/<path:uuid>', methods=['PUT'], strict_slashes=False)
-@ldp.route('/<path:uuid>/fcr:metadata', defaults={'force_rdf' : True},
+@ldp.route('/<path:uid>', methods=['PUT'], strict_slashes=False)
+@ldp.route('/<path:uid>/fcr:metadata', defaults={'force_rdf' : True},
         methods=['PUT'])
-def put_resource(uuid):
+def put_resource(uid):
     '''
     Add a new resource at a specified URI.
     '''
@@ -292,12 +292,12 @@ def put_resource(uuid):
     stream, mimetype = bitstream_from_req()
 
     try:
-        rsrc = LdpFactory.from_provided(uuid, content_length=request.content_length,
+        rsrc = LdpFactory.from_provided(uid, content_length=request.content_length,
                 stream=stream, mimetype=mimetype, handling=handling,
                 disposition=disposition)
         if not request.content_length and rsrc.is_stored:
             raise InvalidResourceError(
-                rsrc.uuid, 'Resource already exists and no data was provided.')
+                rsrc.uid, 'Resource already exists and no data was provided.')
     except InvalidResourceError as e:
         return str(e), 409
     except (ServerManagedTermError, SingleSubjectError) as e:
@@ -310,7 +310,7 @@ def put_resource(uuid):
     except (InvalidResourceError, ResourceExistsError) as e:
         return str(e), 409
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
 
     rsp_headers.update(rsrc.head())
     if ret == Ldpr.RES_CREATED:
@@ -325,13 +325,13 @@ def put_resource(uuid):
     return rsp_body, rsp_code, rsp_headers
 
 
-@ldp.route('/<path:uuid>', methods=['PATCH'], strict_slashes=False)
-def patch_resource(uuid):
+@ldp.route('/<path:uid>', methods=['PATCH'], strict_slashes=False)
+def patch_resource(uid):
     '''
     Update an existing resource with a SPARQL-UPDATE payload.
     '''
     rsp_headers = {'Content-Type' : 'text/plain; charset=utf-8'}
-    rsrc = LdpRs(uuid)
+    rsrc = LdpRs(uid)
     if request.mimetype != 'application/sparql-update':
         return 'Provided content type is not a valid parsable format: {}'\
                 .format(request.mimetype), 415
@@ -341,7 +341,7 @@ def patch_resource(uuid):
     except ResourceNotExistsError as e:
         return str(e), 404
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
     except (ServerManagedTermError, SingleSubjectError) as e:
         return str(e), 412
     else:
@@ -349,13 +349,13 @@ def patch_resource(uuid):
         return '', 204, rsp_headers
 
 
-@ldp.route('/<path:uuid>/fcr:metadata', methods=['PATCH'])
-def patch_resource_metadata(uuid):
-    return patch_resource(uuid)
+@ldp.route('/<path:uid>/fcr:metadata', methods=['PATCH'])
+def patch_resource_metadata(uid):
+    return patch_resource(uid)
 
 
-@ldp.route('/<path:uuid>', methods=['DELETE'])
-def delete_resource(uuid):
+@ldp.route('/<path:uid>', methods=['DELETE'])
+def delete_resource(uid):
     '''
     Delete a resource and optionally leave a tombstone.
 
@@ -382,42 +382,42 @@ def delete_resource(uuid):
         leave_tstone = True
 
     try:
-        LdpFactory.from_stored(uuid, repr_opts).delete(leave_tstone=leave_tstone)
+        LdpFactory.from_stored(uid, repr_opts).delete(leave_tstone=leave_tstone)
     except ResourceNotExistsError as e:
         return str(e), 404
     except TombstoneError as e:
-        return _tombstone_response(e, uuid)
+        return _tombstone_response(e, uid)
 
     return '', 204, headers
 
 
-@ldp.route('/<path:uuid>/fcr:tombstone', methods=['GET', 'POST', 'PUT',
+@ldp.route('/<path:uid>/fcr:tombstone', methods=['GET', 'POST', 'PUT',
         'PATCH', 'DELETE'])
-def tombstone(uuid):
+def tombstone(uid):
     '''
     Handle all tombstone operations.
 
     The only allowed methods are POST and DELETE; any other verb will return a
     405.
     '''
-    logger.debug('Deleting tombstone for {}.'.format(uuid))
-    rsrc = Ldpr(uuid)
+    logger.debug('Deleting tombstone for {}.'.format(uid))
+    rsrc = Ldpr(uid)
     try:
         imr = rsrc.imr
     except TombstoneError as e:
         if request.method == 'DELETE':
-            if e.uuid == uuid:
+            if e.uid == uid:
                 rsrc.purge()
                 return '', 204
             else:
-                return _tombstone_response(e, uuid)
+                return _tombstone_response(e, uid)
         elif request.method == 'POST':
-            if e.uuid == uuid:
+            if e.uid == uid:
                 rsrc_uri = rsrc.resurrect()
                 headers = {'Location' : rsrc_uri}
                 return rsrc_uri, 201, headers
             else:
-                return _tombstone_response(e, uuid)
+                return _tombstone_response(e, uid)
         else:
             return 'Method Not Allowed.', 405
     except ResourceNotExistsError as e:
@@ -429,26 +429,26 @@ def tombstone(uuid):
 def uuid_for_post(parent_uuid=None, slug=None):
     '''
     Validate conditions to perform a POST and return an LDP resource
-    UUID for using with the `post` method.
+    UID for using with the `post` method.
 
     This may raise an exception resulting in a 404 if the parent is not
     found or a 409 if the parent is not a valid container.
     '''
-    def split_if_legacy(uuid):
+    def split_if_legacy(uid):
         if current_app.config['store']['ldp_rs']['legacy_ptree_split']:
-            uuid = g.tbox.split_uuid(uuid)
-        return uuid
+            uid = g.tbox.split_uuid(uid)
+        return uid
 
     # Shortcut!
     if not slug and not parent_uuid:
-        uuid = split_if_legacy(str(uuid4()))
+        uid = split_if_legacy(str(uuid4()))
 
-        return uuid
+        return uid
 
     parent = LdpFactory.from_stored(parent_uuid, repr_opts={'incl_children' : False})
 
     if nsc['fcrepo'].Pairtree in parent.types:
-        raise InvalidResourceError(parent.uuid,
+        raise InvalidResourceError(parent.uid,
                 'Resources cannot be created under a pairtree.')
 
     # Set prefix.
@@ -464,17 +464,17 @@ def uuid_for_post(parent_uuid=None, slug=None):
     else:
         pfx = ''
 
-    # Create candidate UUID and validate.
+    # Create candidate UID and validate.
     if slug:
         cnd_uuid = pfx + slug
         if current_app.rdfly.ask_rsrc_exists(nsc['fcres'][cnd_uuid]):
-            uuid = pfx + split_if_legacy(str(uuid4()))
+            uid = pfx + split_if_legacy(str(uuid4()))
         else:
-            uuid = cnd_uuid
+            uid = cnd_uuid
     else:
-        uuid = pfx + split_if_legacy(str(uuid4()))
+        uid = pfx + split_if_legacy(str(uuid4()))
 
-    return uuid
+    return uid
 
 
 def bitstream_from_req():
@@ -514,10 +514,10 @@ def _get_bitstream(rsrc):
             attachment_filename=rsrc.filename)
 
 
-def _tombstone_response(e, uuid):
+def _tombstone_response(e, uid):
     headers = {
         'Link' : '<{}/fcr:tombstone>; rel="hasTombstone"'.format(request.url),
-    } if e.uuid == uuid else {}
+    } if e.uid == uid else {}
     return str(e), 410, headers
 
 

lakesuperior/exceptions.py

@@ -7,8 +7,8 @@ class ResourceError(RuntimeError):
 
     This usually surfaces at the HTTP level as a 409.
     '''
-    def __init__(self, uuid, msg=None):
-        self.uuid = uuid
+    def __init__(self, uid, msg=None):
+        self.uid = uid
         self.msg = msg
 
 
@@ -20,7 +20,7 @@ class ResourceExistsError(ResourceError):
     This usually surfaces at the HTTP level as a 409.
     '''
     def __str__(self):
-        return self.msg or 'Resource /{} already exists.'.format(self.uuid)
+        return self.msg or 'Resource /{} already exists.'.format(self.uid)
 
 
 
@@ -32,7 +32,7 @@ class ResourceNotExistsError(ResourceError):
     This usually surfaces at the HTTP level as a 404.
     '''
     def __str__(self):
-        return self.msg or 'Resource /{} not found.'.format(self.uuid)
+        return self.msg or 'Resource /{} not found.'.format(self.uid)
 
 
 
@@ -43,7 +43,7 @@ class InvalidResourceError(ResourceError):
     This usually surfaces at the HTTP level as a 409 or other error.
     '''
     def __str__(self):
-        return self.msg or 'Resource /{} is invalid.'.format(self.uuid)
+        return self.msg or 'Resource /{} is invalid.'.format(self.uid)
 
 
 
@@ -53,14 +53,14 @@ class IncompatibleLdpTypeError(ResourceError):
 
     This usually surfaces at the HTTP level as a 415.
     '''
-    def __init__(self, uuid, mimetype, msg=None):
-        super().__init__(uuid, msg)
+    def __init__(self, uid, mimetype, msg=None):
+        super().__init__(uid, msg)
         self.mimetype = mimetype
 
 
     def __str__(self):
         return self.msg or 'Invalid content type \'{}\' for resource /{}'.\
-                format(self.mimetype, self.uuid)
+                format(self.mimetype, self.uid)
 
 
 
@@ -125,13 +125,13 @@ class SingleSubjectError(RuntimeError):
     Raised when a SPARQL-Update query or a RDF payload for a PUT contain
     subjects that do not correspond to the resource being operated on.
     '''
-    def __init__(self, uuid, subject):
-        self.uuid = uuid
+    def __init__(self, uid, subject):
+        self.uid = uid
         self.subject = subject
 
     def __str__(self):
         return '{} is not in the topic of this RDF, which is {}'.format(
-                self.uuid, self.subject)
+                self.uid, self.subject)
 
 
 class TombstoneError(RuntimeError):
@@ -141,13 +141,13 @@ class TombstoneError(RuntimeError):
     It is up to the caller to handle this which may be a benign and expected
     result.
     '''
-    def __init__(self, uuid, ts):
-        self.uuid = uuid
+    def __init__(self, uid, ts):
+        self.uid = uid
         self.ts = ts
 
     def __str__(self):
         return (
             'Discovered tombstone resource at /{}, departed: {}\n'
             'To resurrect this resource, send a POST request to its tombstone.'
-            .format(self.uuid, self.ts)
+            .format(self.uid, self.ts)
         )

lakesuperior/model/ldp_factory.py

@@ -25,7 +25,7 @@ class LdpFactory:
     _logger = logging.getLogger(__name__)
 
     @staticmethod
-    def from_stored(uuid, repr_opts={}, **kwargs):
+    def from_stored(uid, repr_opts={}, **kwargs):
         '''
         Create an instance for retrieval purposes.
 
@@ -35,44 +35,44 @@ class LdpFactory:
 
         N.B. The resource must exist.
 
-        @param uuid UID of the instance.
+        @param uid UID of the instance.
         '''
-        #__class__._logger.info('Retrieving stored resource: {}'.format(uuid))
-        imr_urn = nsc['fcres'][uuid] if uuid else (
+        #__class__._logger.info('Retrieving stored resource: {}'.format(uid))
+        imr_urn = nsc['fcres'][uid] if uid else (
                 model.ldpr.ROOT_RSRC_URI)
 
-        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_urn, RDF.type))
+        rsrc_meta = current_app.rdfly.get_metadata(uid)
+        #__class__._logger.debug('Extracted metadata: {}'.format(
+        #        pformat(set(rsrc_meta.graph))))
+        rdf_types = set(rsrc_meta.graph[imr_urn : RDF.type])
 
         if __class__.LDP_NR_TYPE in rdf_types:
             __class__._logger.info('Resource is a LDP-NR.')
-            rsrc = model.ldp_nr.LdpNr(uuid, repr_opts, **kwargs)
+            rsrc = model.ldp_nr.LdpNr(uid, repr_opts, **kwargs)
         elif __class__.LDP_RS_TYPE in rdf_types:
             __class__._logger.info('Resource is a LDP-RS.')
-            rsrc = model.ldp_rs.LdpRs(uuid, repr_opts, **kwargs)
+            rsrc = model.ldp_rs.LdpRs(uid, repr_opts, **kwargs)
         else:
-            raise ResourceNotExistsError(uuid)
+            raise ResourceNotExistsError(uid)
 
-        # Sneak in the already extracted IMR to save a query.
-        rsrc.imr = imr
+        # Sneak in the already extracted metadata to save a query.
+        rsrc._metadata = rsrc_meta
 
         return rsrc
 
 
     @staticmethod
-    def from_provided(uuid, content_length, mimetype, stream, **kwargs):
+    def from_provided(uid, content_length, mimetype, stream, **kwargs):
         '''
         Determine LDP type from request content.
 
-        @param uuid (string) UUID of the resource to be created or updated.
+        @param uid (string) UID of the resource to be created or updated.
         @param content_length (int) The provided content length.
         @param mimetype (string) The provided content MIME type.
         @param stream (IOStream) The provided data stream. This can be RDF or
         non-RDF content.
         '''
-        urn = nsc['fcres'][uuid]
+        urn = nsc['fcres'][uid]
 
         logger = __class__._logger
 
@@ -81,7 +81,7 @@ class LdpFactory:
             logger.info('No data received in request. '
                     'Creating empty container.')
             inst = model.ldp_rs.Ldpc(
-                    uuid, provided_imr=Resource(Graph(), urn), **kwargs)
+                    uid, provided_imr=Resource(Graph(), urn), **kwargs)
 
         elif __class__.is_rdf_parsable(mimetype):
             # Create container and populate it with provided RDF data.
@@ -106,23 +106,23 @@ class LdpFactory:
             else:
                 cls = model.ldp_rs.Ldpc
 
-            inst = cls(uuid, provided_imr=provided_imr, **kwargs)
+            inst = cls(uid, provided_imr=provided_imr, **kwargs)
 
             # Make sure we are not updating an LDP-RS with an LDP-NR.
             if inst.is_stored and __class__.LDP_NR_TYPE in inst.ldp_types:
-                raise IncompatibleLdpTypeError(uuid, mimetype)
+                raise IncompatibleLdpTypeError(uid, mimetype)
 
             inst._check_mgd_terms(inst.provided_imr.graph)
 
         else:
             # Create a LDP-NR and equip it with the binary file provided.
             provided_imr = Resource(Graph(), urn)
-            inst = model.ldp_nr.LdpNr(uuid, stream=stream, mimetype=mimetype,
+            inst = model.ldp_nr.LdpNr(uid, stream=stream, mimetype=mimetype,
                     provided_imr=provided_imr, **kwargs)
 
             # Make sure we are not updating an LDP-NR with an LDP-RS.
             if inst.is_stored and __class__.LDP_RS_TYPE in inst.ldp_types:
-                raise IncompatibleLdpTypeError(uuid, mimetype)
+                raise IncompatibleLdpTypeError(uid, mimetype)
 
         logger.info('Creating resource of type: {}'.format(
                 inst.__class__.__name__))
@@ -132,7 +132,7 @@ class LdpFactory:
         except:
             types = set()
         if nsc['fcrepo'].Pairtree in types:
-            raise InvalidResourceError(inst.uuid)
+            raise InvalidResourceError(inst.uid)
 
         return inst
 

lakesuperior/model/ldpr.py

@@ -44,7 +44,8 @@ def atomic(fn):
             raise
         else:
             self._logger.info('Committing transaction.')
-            self.rdfly.optimize_edits()
+            if hasattr(self.rdfly.store, '_edits'):
+                self.rdfly.optimize_edits()
             self.rdfly.store.commit()
             for ev in request.changelog:
                 #self._logger.info('Message: {}'.format(pformat(ev)))
@@ -121,7 +122,7 @@ class Ldpr(metaclass=ABCMeta):
 
     ## MAGIC METHODS ##
 
-    def __init__(self, uuid, repr_opts={}, provided_imr=None, **kwargs):
+    def __init__(self, uid, repr_opts={}, provided_imr=None, **kwargs):
         '''Instantiate an in-memory LDP resource that can be loaded from and
         persisted to storage.
 
@@ -129,7 +130,7 @@ class Ldpr(metaclass=ABCMeta):
         layout should commit an open transaction. Methods are wrapped in a
         transaction by using the `@atomic` decorator.
 
-        @param uuid (string) UUID of the resource. If None (must be explicitly
+        @param uid (string) uid of the resource. If None (must be explicitly
         set) it refers to the root node. It can also be the full URI or URN,
         in which case it will be converted.
         @param repr_opts (dict) Options used to retrieve the IMR. See
@@ -138,11 +139,11 @@ class Ldpr(metaclass=ABCMeta):
         operations isuch as `PUT` or `POST`, serialized as a string. This sets
         the `provided_imr` property.
         '''
-        self.uuid = g.tbox.uri_to_uuid(uuid) \
-                if isinstance(uuid, URIRef) else uuid
-        self.urn = nsc['fcres'][uuid] \
-                if self.uuid else ROOT_RSRC_URI
-        self.uri = g.tbox.uuid_to_uri(self.uuid)
+        self.uid = g.tbox.uri_to_uuid(uid) \
+                if isinstance(uid, URIRef) else uid
+        self.urn = nsc['fcres'][uid] \
+                if self.uid else ROOT_RSRC_URI
+        self.uri = g.tbox.uuid_to_uri(self.uid)
 
         self.rdfly = current_app.rdfly
         self.nonrdfly = current_app.nonrdfly
@@ -181,7 +182,7 @@ class Ldpr(metaclass=ABCMeta):
             else:
                 imr_options = {}
             options = dict(imr_options, strict=True)
-            self._imr = self.rdfly.extract_imr(self.uuid, **options)
+            self._imr = self.rdfly.extract_imr(self.uid, **options)
 
         return self._imr
 
@@ -215,7 +216,7 @@ class Ldpr(metaclass=ABCMeta):
         Get resource metadata.
         '''
         if not hasattr(self, '_metadata'):
-            self._metadata = self.rdfly.get_metadata(self.uuid)
+            self._metadata = self.rdfly.get_metadata(self.uid)
 
         return self._metadata
 
@@ -248,7 +249,7 @@ class Ldpr(metaclass=ABCMeta):
                 imr_options = {}
             options = dict(imr_options, strict=True)
             try:
-                self._imr = self.rdfly.extract_imr(self.uuid, **options)
+                self._imr = self.rdfly.extract_imr(self.uid, **options)
             except ResourceNotExistsError:
                 self._imr = Resource(Graph(), self.urn)
                 for t in self.base_types:
@@ -327,7 +328,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.uuid)
+                self._is_stored = self.rdfly.ask_rsrc_exists(self.uid)
 
         return self._is_stored
 
@@ -339,9 +340,10 @@ class Ldpr(metaclass=ABCMeta):
         @return set(rdflib.term.URIRef)
         '''
         if not hasattr(self, '_types'):
+            #import pdb; pdb.set_trace()
             if hasattr(self, '_imr') and len(self.imr.graph):
                 imr = self.imr
-            elif hasattr(self, 'provided_imr') and \
+            elif getattr(self, 'provided_imr', None) and \
                     len(self.provided_imr.graph):
                 imr = self.provided_imr
             else:
@@ -460,7 +462,7 @@ class Ldpr(metaclass=ABCMeta):
 
         @EXPERIMENTAL
         '''
-        tstone_trp = set(self.rdfly.extract_imr(self.uuid, strict=False).graph)
+        tstone_trp = set(self.rdfly.extract_imr(self.uid, strict=False).graph)
 
         ver_rsp = self.version_info.query('''
         SELECT ?uid {
@@ -584,8 +586,7 @@ class Ldpr(metaclass=ABCMeta):
         if ref_int:
             self._check_ref_int(ref_int)
 
-        import pdb; pdb.set_trace()
-        self.rdfly.create_or_replace_rsrc(self.uuid, self.provided_imr.graph,
+        self.rdfly.create_or_replace_rsrc(self.uid, self.provided_imr.graph,
                 self.metadata.graph)
 
         self._set_containment_rel()
@@ -665,16 +666,16 @@ class Ldpr(metaclass=ABCMeta):
         '''
         self._logger.info('Purging resource {}'.format(self.urn))
         imr = self.rdfly.extract_imr(
-                self.uuid, incl_inbound=True, strict=False)
+                self.uid, incl_inbound=True, strict=False)
 
         # Remove resource itself.
-        self.rdfly.modify_dataset(self.uuid, {(self.urn, None, None)}, types=None)
+        self.rdfly.modify_dataset(self.uid, {(self.urn, None, None)}, types=None)
 
         # Remove fragments.
         for frag_urn in imr.graph[
                 : nsc['fcsystem'].fragmentOf : self.urn]:
             self.rdfly.modify_dataset(
-                    self.uuid, {(frag_urn, None, None)}, types={})
+                    self.uid, {(frag_urn, None, None)}, types={})
 
         # Remove snapshots.
         for snap_urn in self.versions:
@@ -682,7 +683,7 @@ class Ldpr(metaclass=ABCMeta):
                 (snap_urn, None, None),
                 (None, None, snap_urn),
             }
-            self.rdfly.modify_dataset(self.uuid, remove_trp, types={})
+            self.rdfly.modify_dataset(self.uid, remove_trp, types={})
 
         # Remove inbound references.
         if inbound:
@@ -700,7 +701,7 @@ class Ldpr(metaclass=ABCMeta):
         '''
         # Create version resource from copying the current state.
         ver_add_gr = Graph()
-        vers_uuid = '{}/{}'.format(self.uuid, self.RES_VER_CONT_LABEL)
+        vers_uuid = '{}/{}'.format(self.uid, self.RES_VER_CONT_LABEL)
         ver_uuid = '{}/{}'.format(vers_uuid, ver_uid)
         ver_urn = nsc['fcres'][ver_uuid]
         ver_add_gr.add((ver_urn, RDF.type, nsc['fcrepo'].Version))
@@ -725,7 +726,7 @@ class Ldpr(metaclass=ABCMeta):
                         t[1], t[2]))
 
         self.rdfly.modify_dataset(
-                self.uuid, add_trp=ver_add_gr, types={nsc['fcrepo'].Version})
+                self.uid, add_trp=ver_add_gr, types={nsc['fcrepo'].Version})
 
         # Add version metadata.
         meta_add_gr = Graph()
@@ -737,7 +738,7 @@ class Ldpr(metaclass=ABCMeta):
                 (ver_urn, nsc['fcrepo'].hasVersionLabel, Literal(ver_uid)))
 
         self.rdfly.modify_dataset(
-                self.uuid, add_trp=meta_add_gr, types={nsc['fcrepo'].Metadata})
+                self.uid, add_trp=meta_add_gr, types={nsc['fcrepo'].Metadata})
 
         # Update resource.
         rsrc_add_gr = Graph()
@@ -772,7 +773,7 @@ class Ldpr(metaclass=ABCMeta):
         type = self.types
         actor = self.metadata.value(nsc['fcrepo'].createdBy)
 
-        ret = self.rdfly.modify_dataset(self.uuid, remove_trp, add_trp,
+        ret = self.rdfly.modify_dataset(self.uid, remove_trp, add_trp,
                 remove_meta, add_meta)
 
         if notify and current_app.config.get('messaging'):
@@ -801,7 +802,7 @@ class Ldpr(metaclass=ABCMeta):
                     # to the metadata graph.
                     gr.add((frag, nsc['fcsystem'].fragmentOf, s))
             if not s == self.urn:
-                raise SingleSubjectError(s, self.uuid)
+                raise SingleSubjectError(s, self.uid)
 
 
     def _check_ref_int(self, config):
@@ -892,7 +893,7 @@ class Ldpr(metaclass=ABCMeta):
 
 
     def _set_containment_rel(self):
-        '''Find the closest parent in the path indicated by the UUID and
+        '''Find the closest parent in the path indicated by the uid and
         establish a containment triple.
 
         E.g. if only urn:fcres:a (short: a) exists:
@@ -902,7 +903,7 @@ class Ldpr(metaclass=ABCMeta):
         '''
         if self.urn == ROOT_RSRC_URI:
             return
-        elif '/' in self.uuid:
+        elif '/' in self.uid:
             # Traverse up the hierarchy to find the parent.
             parent_uid = self._find_parent_or_create_pairtree()
         else:
@@ -927,7 +928,7 @@ class Ldpr(metaclass=ABCMeta):
 
         @return string Resource UID.
         '''
-        path_components = self.uuid.split('/')
+        path_components = self.uid.split('/')
 
          # If there is only one element, the parent is the root node.
         if len(path_components) < 2:
@@ -941,7 +942,7 @@ class Ldpr(metaclass=ABCMeta):
         )
         rev_search_order = reversed(list(fwd_search_order))
 
-        cur_child_uid = self.uuid
+        cur_child_uid = self.uid
         parent_uid = ROOT_UID # Defaults to root
         segments = []
         for cparent_uid in rev_search_order:
@@ -980,21 +981,29 @@ class Ldpr(metaclass=ABCMeta):
         between a and a/b and between a/b and a/b/c in order to maintain the
         `containment chain.
         '''
-        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, nsc['fcres'][child_uid])
-        imr.add(nsc['ldp'].contains, self.urn)
-        imr.add(nsc['fcrepo'].hasParent, nsc['fcres'][real_parent_uid])
+        rsrc_uri = nsc['fcres'][uid]
+
+        state_trp = {
+            (rsrc_uri, nsc['fcrepo'].contains, nsc['fcres'][child_uid]),
+            (rsrc_uri, nsc['ldp'].contains, self.urn),
+        }
+
+        meta_trp = {
+            (rsrc_uri, RDF.type, nsc['ldp'].Container),
+            (rsrc_uri, RDF.type, nsc['ldp'].BasicContainer),
+            (rsrc_uri, RDF.type, nsc['ldp'].RDFSource),
+            (rsrc_uri, RDF.type, nsc['fcrepo'].Pairtree),
+            (rsrc_uri, nsc['fcrepo'].hasParent, nsc['fcres'][real_parent_uid]),
+        }
+
+        self.rdfly.modify_dataset(
+                uid, add_trp=state_trp, add_meta=meta_trp)
 
         # If the path segment is just below root
         if '/' not in uid:
-            imr.graph.addN((nsc['fcsystem'].root, nsc['fcrepo'].contains,
-                    nsc['fcres'][uid], ROOT_GRAPH_URI))
-
-        self.rdfly.modify_dataset(self.uuid, add_trp=imr.graph)
+            self.rdfly.modify_dataset(ROOT_UID, add_meta={
+                (ROOT_RSRC_URI, nsc['fcrepo'].contains, nsc['fcres'][uid])
+            })
 
 
     def _add_ldp_dc_ic_rel(self, cont_rsrc):
@@ -1003,11 +1012,11 @@ class Ldpr(metaclass=ABCMeta):
 
         @param cont_rsrc (rdflib.resource.Resouce)  The container resource.
         '''
-        cont_p = set(cont_rsrc.imr.graph.predicates())
+        cont_p = set(cont_rsrc.metadata.graph.predicates())
         add_gr = Graph()
 
         self._logger.info('Checking direct or indirect containment.')
-        #self._logger.debug('Parent predicates: {}'.format(cont_p))
+        self._logger.debug('Parent predicates: {}'.format(cont_p))
 
         add_gr.add((self.urn, nsc['fcrepo'].hasParent, cont_rsrc.urn))
         if self.MBR_RSRC_URI in cont_p and self.MBR_REL_URI in cont_p:

lakesuperior/store_layouts/ldp_rs/bdb_connector.py

@@ -26,10 +26,10 @@ class BdbConnector(BaseConnector):
 
         Also open the store, which must be closed by the __del__ method.
         '''
-        #self.store = plugin.get('Sleepycat', Store)(
-        #        identifier=URIRef('urn:fcsystem:lsup'))
+        self.store = plugin.get('Sleepycat', Store)(
+                identifier=URIRef('urn:fcsystem:lsup'))
         self.ds = Dataset('Sleepycat', default_union=True)
-        self.store = self.ds.store
+        #self.store = self.ds.store
         self.ds.open(location, create=True)
 
 
@@ -37,4 +37,4 @@ class BdbConnector(BaseConnector):
         '''
         Close store connection.
         '''
-        self.ds.close(commit_pending_transaction=False)
+        self.store.close(commit_pending_transaction=False)

lakesuperior/store_layouts/ldp_rs/rsrc_centric_layout.py

@@ -43,18 +43,13 @@ class RsrcCentricLayout(BaseRdfLayout):
         '''
         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()
 
 
@@ -85,7 +80,7 @@ class RsrcCentricLayout(BaseRdfLayout):
             if embed_children:
                 embed_children_trp = '?c ?cp ?co .'
                 embed_children_qry = '''
-                OPTIONAL {{
+                UNION {{
                   ?s ldp:contains ?c .
                   {}
                 }}
@@ -98,13 +93,14 @@ class RsrcCentricLayout(BaseRdfLayout):
             ?meta_s ?meta_p ?meta_o .
             ?s ?p ?o .{inb_cnst}
             {embed_chld_t}
-            ?s fcrepo:writable true .
+            #?s fcrepo:writable true .
         }}
         WHERE {{
-          GRAPH ?mg {{
-            ?meta_s ?meta_p ?meta_o .
-          }}
-          OPTIONAL {{
+          {{
+            GRAPH ?mg {{
+              ?meta_s ?meta_p ?meta_o .
+            }}
+          }} UNION {{
             GRAPH ?sg {{
               ?s ?p ?o .{inb_qry}{incl_chld}{embed_chld}
             }}
@@ -117,8 +113,9 @@ class RsrcCentricLayout(BaseRdfLayout):
                 )
 
         mg = ROOT_GRAPH_URI if uid == '' else nsc['fcmeta'][uid]
+        #import pdb; pdb.set_trace()
         try:
-            qres = self.store.query(q, initBindings={'mg': mg,
+            qres = self.ds.query(q, initBindings={'mg': mg,
                 'sg': self._state_uri(uid, ver_uid)})
         except ResultException:
             # RDFlib bug: https://github.com/RDFLib/rdflib/issues/775
@@ -164,12 +161,47 @@ class RsrcCentricLayout(BaseRdfLayout):
 
     def get_metadata(self, uid):
         '''
-        See base_rdf_layout.get_version_info.
+        This is an optimized query to get everything the application needs to
+        insert new contents, and nothing more.
+        '''
+        rsrc_uri = nsc['fcres'][uid]
+        meta_uri = ROOT_GRAPH_URI if uid == ROOT_UID else nsc['fcmeta'][uid]
+        state_uri = ROOT_GRAPH_URI if uid == ROOT_UID else nsc['fcmeta'][uid]
+        meta_gr = self.ds.graph(meta_uri)
+        state_gr = self.ds.graph(state_uri)
+        cont_qry = '''
+        CONSTRUCT {
+          ?s ldp:membershipResource ?mr ;
+            ldp:hasMemberRelation ?hmr ;
+            ldp:insertedContentRelation ?icr ;
+              ?p ?o .
+        } WHERE {
+          {
+            GRAPH ?mg {
+              ?s ?p ?o .
+            }
+          } UNION {
+            GRAPH ?sg {
+              {
+                ?s ldp:membershipResource ?mr ;
+                  ldp:hasMemberRelation ?hmr .
+              } UNION {
+                ?s ldp:insertedContentRelation ?icr .
+              }
+            }
+          }
+        }
         '''
-        gr_uri = ROOT_GRAPH_URI if uid == ROOT_UID else nsc['fcmeta'][uid]
-        meta_gr = self.ds.graph(gr_uri)
+        try:
+            qres = self.ds.query(cont_qry, initBindings={
+                    's': rsrc_uri, 'mg': meta_uri, 'sg': state_uri})
+        except ResultException:
+            # RDFlib bug: https://github.com/RDFLib/rdflib/issues/775
+            gr = Graph()
+        else:
+            gr = qres.graph
 
-        return Resource(meta_gr | Graph(), nsc['fcres'][uid])
+        return Resource(gr, rsrc_uri)
 
 
     def get_version(self, uid, ver_uid):
@@ -252,7 +284,6 @@ class RsrcCentricLayout(BaseRdfLayout):
                 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

@@ -37,18 +37,18 @@ class Toolbox:
         return URIRef(s)
 
 
-    def uuid_to_uri(self, uuid):
-        '''Convert a UUID to a URI.
+    def uuid_to_uri(self, uid):
+        '''Convert a UID to a URI.
 
         @return URIRef
         '''
-        uri = '{}/{}'.format(g.webroot, uuid) if uuid else g.webroot
+        uri = '{}/{}'.format(g.webroot, uid) if uid else g.webroot
 
         return URIRef(uri)
 
 
     def uri_to_uuid(self, uri):
-        '''Convert an absolute URI (internal or external) to a UUID.
+        '''Convert an absolute URI (internal or external) to a UID.
 
         @return string
         '''
@@ -272,7 +272,7 @@ class Toolbox:
 
     def split_uuid(self, uuid):
         '''
-        Split a UUID into pairtree segments. This mimics FCREPO4 behavior.
+        Split a UID into pairtree segments. This mimics FCREPO4 behavior.
         '''
         path = '{}/{}/{}/{}/{}'.format(uuid[:2], uuid[2:4],
                 uuid[4:6], uuid[6:8], uuid)

tests/10K_children.py

@@ -8,7 +8,7 @@ import requests
 
 default_n = 10000
 webroot = 'http://localhost:8000/ldp'
-#webroot = 'http://lake.devbox.local/fcrepo/rest'
+#webroot = 'http://localhost:8080/fcrepo/rest'
 container = webroot + '/pomegranate'
 datafile = 'tests/data/marcel_duchamp_single_subject.ttl'
 
@@ -34,8 +34,9 @@ print('Inserting {} children.'.format(n))
 data = open(datafile, 'rb').read()
 try:
     for i in range(1, n):
-        requests.put('{}/{}'.format(container, uuid4()), data=data, headers={
-            'content-type': 'text/turtle'})
+        rsp = requests.put('{}/{}'.format(container, uuid4()), data=data,
+                headers={ 'content-type': 'text/turtle'})
+        rsp.raise_for_status()
         if i % 10 == 0:
             now = arrow.utcnow()
             tdelta = now - ckpt

tests/bdb.py

@@ -11,7 +11,7 @@ from rdflib import plugin
 from rdflib.store import Store
 from rdflib.term import URIRef
 
-default_n = 100000
+default_n = 10000
 sys.stdout.write('How many resources? [{}] >'.format(default_n))
 choice = input().lower()
 n = int(choice) if choice else default_n
@@ -28,17 +28,40 @@ ckpt = start
 for i in range(1, n):
     try:
         subj = URIRef('http://ex.org/rdf/{}'.format(uuid4()))
-        gr = ds.graph('http://ex.org/graph#g{}'.format(i))
+        pomegranate = URIRef('http://ex.org/pomegranate')
+        #gr = ds.graph('http://ex.org/graph#g{}'.format(i))
+        gr = ds.graph('http://ex.org/graph#g1')
         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))
+        gr.add((pomegranate, URIRef('http://ex.org/p2'), subj))
+
+        q = '''
+        CONSTRUCT {
+            ?meta_s ?meta_p ?meta_o .
+            ?s ?p ?o .
+            ?s <info:fcrepo#writable> true .
+        }
+        WHERE {
+          GRAPH ?mg {
+            ?meta_s ?meta_p ?meta_o .
+          }
+          OPTIONAL {
+            GRAPH ?sg {
+              ?s ?p ?o .
+              FILTER ( ?p != <http://ex.org/p2> )
+            }
+          }
+        }
+        '''
+        qres = ds.query(q, initBindings={'s': pomegranate, 'mg': gr, 'sg': gr})
 
-        now = arrow.utcnow()
-        tdelta = now - ckpt
-        ckpt = now
         if i % 100 == 0:
-            print('Record: {}\tTime elapsed: {}'.format(i, tdelta))
+            now = arrow.utcnow()
+            tdelta = now - ckpt
+            ckpt = now
+            print('Record: {}\tTime this round: {}'.format(i, tdelta))
+            #print('Qres size: {}'.format(len(qres)))
     except KeyboardInterrupt:
         print('Interrupted after {} iterations.'.format(i))
         break