Straight use of SPARQL statements with PATCH.

lakesuperior/endpoints/ldp.py

@@ -526,17 +526,16 @@ def _get_bitstream(rsrc):
 
 def _tombstone_response(e, uid):
     headers = {
-        'Link' : '<{}/fcr:tombstone>; rel="hasTombstone"'.format(request.url),
+        'Link': '<{}/fcr:tombstone>; rel="hasTombstone"'.format(request.url),
     } if e.uid == uid else {}
     return str(e), 410, headers
 
 
-
 def set_post_put_params():
     '''
     Sets handling and content disposition for POST and PUT by parsing headers.
     '''
-    handling = None
+    handling = 'strict'
     if 'prefer' in request.headers:
         prefer = g.tbox.parse_rfc7240(request.headers['prefer'])
         logger.debug('Parsed Prefer header: {}'.format(prefer))

lakesuperior/exceptions.py

@@ -82,7 +82,7 @@ class ServerManagedTermError(RuntimeError):
 
     This usually surfaces at the HTTP level as a 409 or other error.
     '''
-    def __init__(self, terms, term_type):
+    def __init__(self, terms, term_type=None):
         if term_type == 's':
             term_name = 'subject'
         elif term_type == 'p':

lakesuperior/model/ldp_factory.py

@@ -115,7 +115,8 @@ class LdpFactory:
             if inst.is_stored and __class__.LDP_NR_TYPE in inst.ldp_types:
                 raise IncompatibleLdpTypeError(uid, mimetype)
 
-            inst._check_mgd_terms(inst.provided_imr.graph)
+            if kwargs.get('handling', 'strict') != 'none':
+                inst._check_mgd_terms(inst.provided_imr.graph)
 
         else:
             # Create a LDP-NR and equip it with the binary file provided.

lakesuperior/model/ldp_rs.py

@@ -1,7 +1,9 @@
 #from copy import deepcopy
 
-from flask import g
+from flask import current_app, g
 from rdflib import Graph
+from rdflib.plugins.sparql.algebra import translateUpdate
+from rdflib.plugins.sparql.parser import parseUpdate
 
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
 from lakesuperior.model.ldpr import Ldpr, atomic
@@ -47,54 +49,88 @@ class LdpRs(Ldpr):
 
         @param update_str (string) SPARQL-Update staements.
         '''
+        self.handling = 'strict'
         local_update_str = g.tbox.localize_ext_str(update_str, self.urn)
-        delta = self._sparql_delta(local_update_str)
-        #self._ensure_single_subject_rdf(delta[0], add_fragment=False)
-        #self._ensure_single_subject_rdf(delta[1])
 
-        return self._modify_rsrc(self.RES_UPDATED, *delta)
+        return self._sparql_update(local_update_str)
 
 
-    def _sparql_delta(self, q):
+    def _sparql_update(self, update_str, notify=True):
         '''
-        Calculate the delta obtained by a SPARQL Update operation.
+        Apply a SPARQL update to a resource.
 
-        This is a critical component of the SPARQL update prcess and does a
-        couple of things:
+        The SPARQL string is validated beforehand to make sure that it does
+        not contain server-managed terms.
 
-        1. It ensures that no resources outside of the subject of the request
-        are modified (e.g. by variable subjects)
-        2. It verifies that none of the terms being modified is server managed.
+        In theory, server-managed terms in DELETE statements are harmless
+        because the patch is only applied over the user-provided triples, but
+        at the moment those are also checked.
+        '''
+        # Parse the SPARQL update string and validate contents.
+        qry_struct = translateUpdate(parseUpdate(update_str))
+        check_ins_gr = Graph()
+        check_del_gr = Graph()
+        for stmt in qry_struct:
+            try:
+                check_ins_gr += set(stmt.insert.triples)
+            except AttributeError:
+                pass
+            try:
+                check_del_gr += set(stmt.delete.triples)
+            except AttributeError:
+                pass
 
-        This method extracts an in-memory copy of the resource and performs the
-        query on that once it has checked if any of the server managed terms is
-        in the delta. If it is, it raises an exception.
+        self._check_mgd_terms(check_ins_gr)
+        self._check_mgd_terms(check_del_gr)
 
-        NOTE: This only checks if a server-managed term is effectively being
-        modified. If a server-managed term is present in the query but does not
-        cause any change in the updated resource, no error is raised.
+        self.rdfly.patch_rsrc(self.uid, update_str)
 
-        @return tuple(rdflib.Graph) Remove and add graphs. These can be used
-        with `BaseStoreLayout.update_resource` and/or recorded as separate
-        events in a provenance tracking system.
-        '''
-        #self._logger.debug('Provided SPARQL query: {}'.format(q))
-        pre_gr = self.imr.graph
+        if notify and current_app.config.get('messaging'):
+            self._send_msg(self.RES_UPDATED, check_del_gr, check_ins_gr)
+
+        return self.RES_UPDATED
+
+
+    #def _sparql_delta(self, q):
+    #    '''
+    #    Calculate the delta obtained by a SPARQL Update operation.
+
+    #    This is a critical component of the SPARQL update prcess and does a
+    #    couple of things:
+
+    #    1. It ensures that no resources outside of the subject of the request
+    #    are modified (e.g. by variable subjects)
+    #    2. It verifies that none of the terms being modified is server managed.
+
+    #    This method extracts an in-memory copy of the resource and performs the
+    #    query on that once it has checked if any of the server managed terms is
+    #    in the delta. If it is, it raises an exception.
+
+    #    NOTE: This only checks if a server-managed term is effectively being
+    #    modified. If a server-managed term is present in the query but does not
+    #    cause any change in the updated resource, no error is raised.
+
+    #    @return tuple(rdflib.Graph) Remove and add graphs. These can be used
+    #    with `BaseStoreLayout.update_resource` and/or recorded as separate
+    #    events in a provenance tracking system.
+    #    '''
+    #    self._logger.debug('Provided SPARQL query: {}'.format(q))
+    #    pre_gr = self.imr.graph
 
-        post_gr = pre_gr | Graph()
-        post_gr.update(q)
+    #    post_gr = pre_gr | Graph()
+    #    post_gr.update(q)
 
-        remove_gr, add_gr = self._dedup_deltas(pre_gr, post_gr)
+    #    remove_gr, add_gr = self._dedup_deltas(pre_gr, post_gr)
 
-        #self._logger.debug('Removing: {}'.format(
-        #    remove_gr.serialize(format='turtle').decode('utf8')))
-        #self._logger.debug('Adding: {}'.format(
-        #    add_gr.serialize(format='turtle').decode('utf8')))
+    #    #self._logger.debug('Removing: {}'.format(
+    #    #    remove_gr.serialize(format='turtle').decode('utf8')))
+    #    #self._logger.debug('Adding: {}'.format(
+    #    #    add_gr.serialize(format='turtle').decode('utf8')))
 
-        remove_gr = self._check_mgd_terms(remove_gr)
-        add_gr = self._check_mgd_terms(add_gr)
+    #    remove_gr = self._check_mgd_terms(remove_gr)
+    #    add_gr = self._check_mgd_terms(add_gr)
 
-        return set(remove_gr), set(add_gr)
+    #    return set(remove_gr), set(add_gr)
 
 
 

lakesuperior/model/ldpr.py

@@ -8,7 +8,7 @@ from uuid import uuid4
 
 import arrow
 
-from flask import current_app, g, request
+from flask import current_app, g
 from rdflib import Graph
 from rdflib.resource import Resource
 from rdflib.namespace import RDF
@@ -38,7 +38,7 @@ def atomic(fn):
     transaction.
     '''
     def wrapper(self, *args, **kwargs):
-        request.changelog = []
+        g.changelog = []
         try:
             ret = fn(self, *args, **kwargs)
         except:
@@ -51,7 +51,7 @@ def atomic(fn):
             #    # @FIXME ugly.
             #    self.rdfly._conn.optimize_edits()
             self.rdfly.store.commit()
-            for ev in request.changelog:
+            for ev in g.changelog:
                 #self._logger.info('Message: {}'.format(pformat(ev)))
                 self._send_event_msg(*ev)
             return ret
@@ -493,7 +493,6 @@ class Ldpr(metaclass=ABCMeta):
         ORDER BY DESC(?ts)
         LIMIT 1
         ''')
-        #import pdb; pdb.set_trace()
         ver_uid = str(ver_rsp.bindings[0]['uid'])
         ver_trp = set(self.rdfly.get_metadata(self.uid, ver_uid).graph)
 
@@ -577,8 +576,9 @@ class Ldpr(metaclass=ABCMeta):
 
     def _is_trp_managed(self, t):
         '''
-        Return whether a triple is server-managed.
-        This is true if one of its terms is in the managed terms list.
+        Whether a triple is server-managed.
+
+        @return boolean
         '''
         return t[1] in srv_mgd_predicates or (
                 t[1] == RDF.type and t[2] in srv_mgd_types)
@@ -718,6 +718,18 @@ class Ldpr(metaclass=ABCMeta):
         #    if not isinstance(trp, set):
         #        trp = set(trp)
 
+        ret = self.rdfly.modify_rsrc(self.uid, remove_trp, add_trp)
+
+        if notify and current_app.config.get('messaging'):
+            self._send_msg(ev_type, remove_trp, add_trp)
+
+        return ret
+
+
+    def _send_msg(self, ev_type, remove_trp=None, add_trp=None):
+        '''
+        Sent a message about a changed (created, modified, deleted) resource.
+        '''
         try:
             type = self.types
             actor = self.metadata.value(nsc['fcrepo'].createdBy)
@@ -730,17 +742,12 @@ class Ldpr(metaclass=ABCMeta):
                 elif actor is None and t[1] == nsc['fcrepo'].createdBy:
                     actor = t[2]
 
-        ret = self.rdfly.modify_rsrc(self.uid, remove_trp, add_trp)
-
-        if notify and current_app.config.get('messaging'):
-            request.changelog.append((set(remove_trp), set(add_trp), {
-                'ev_type' : ev_type,
-                'time' : g.timestamp,
-                'type' : type,
-                'actor' : actor,
-            }))
-
-        return ret
+        g.changelog.append((set(remove_trp), set(add_trp), {
+            'ev_type' : ev_type,
+            'time' : g.timestamp,
+            'type' : type,
+            'actor' : actor,
+        }))
 
 
     # Not used. @TODO Deprecate or reimplement depending on requirements.
@@ -781,10 +788,6 @@ class Ldpr(metaclass=ABCMeta):
         '''
         Check whether server-managed terms are in a RDF payload.
         '''
-        # @FIXME Need to be more consistent
-        if getattr(self, 'handling', 'none') == 'none':
-            return gr
-
         offending_subjects = set(gr.subjects()) & srv_mgd_subjects
         if offending_subjects:
             if self.handling=='strict':
@@ -987,7 +990,6 @@ class Ldpr(metaclass=ABCMeta):
                 self._logger.info('Parent is an indirect container.')
                 cont_rel_uri = cont_rsrc.metadata.value(
                         self.INS_CNT_REL_URI).identifier
-                #import pdb; pdb.set_trace()
                 o = self.provided_imr.value(cont_rel_uri).identifier
                 self._logger.debug('Target URI: {}'.format(o))
                 self._logger.debug('Creating IC triples.')

lakesuperior/store_layouts/ldp_rs/rsrc_centric_layout.py

@@ -314,6 +314,23 @@ class RsrcCentricLayout:
         return self._parse_construct(qry, init_bindings={'s': uri})
 
 
+    def patch_rsrc(self, uid, qry):
+        '''
+        Patch a resource with SPARQL-Update statements.
+
+        The statement(s) is/are executed on the user-provided graph only
+        to ensure that the scope is limited to the resource.
+
+        @param uid (string) UID of the resource to be patched.
+        @param qry (dict) Parsed and translated query, or query string.
+        '''
+        gr = self.ds.graph(nsc['fcmain'][uid])
+        self._logger.debug('Updating graph {} with statements: {}'.format(
+            nsc['fcmain'][uid], qry))
+
+        return gr.update(qry)
+
+
     def purge_rsrc(self, uid, inbound=True, backup_uid=None):
         '''
         Completely delete a resource and (optionally) its references.

tests/endpoints/test_ldp.py

@@ -478,16 +478,29 @@ class TestPrefHeader:
         '''
         Trying to PUT an existing resource should:
 
-        - Return a 204 if the payload is empty
+        - Return a 409 if the payload is empty
         - Return a 204 if the payload is RDF, server-managed triples are
           included and the 'Prefer' header is set to 'handling=lenient'
         - Return a 412 (ServerManagedTermError) if the payload is RDF,
-          server-managed triples are included and handling is set to 'strict'
+          server-managed triples are included and handling is set to 'strict',
+          or not set.
         '''
         path = '/ldp/put_pref_header01'
         assert self.client.put(path).status_code == 201
         assert self.client.get(path).status_code == 200
         assert self.client.put(path).status_code == 409
+
+        # Default handling is strict.
+        with open('tests/data/rdf_payload_w_srv_mgd_trp.ttl', 'rb') as f:
+            rsp_default = self.client.put(
+                path,
+                headers={
+                    'Content-Type' : 'text/turtle',
+                },
+                data=f
+            )
+        assert rsp_default.status_code == 412
+
         with open('tests/data/rdf_payload_w_srv_mgd_trp.ttl', 'rb') as f:
             rsp_len = self.client.put(
                 path,
@@ -498,6 +511,7 @@ class TestPrefHeader:
                 data=f
             )
         assert rsp_len.status_code == 204
+
         with open('tests/data/rdf_payload_w_srv_mgd_trp.ttl', 'rb') as f:
             rsp_strict = self.client.put(
                 path,