Separate graph store connector from store layout.

lakesuperior/store_layouts/rdf/base_rdf_layout.py

@@ -2,33 +2,19 @@ import logging
 
 from abc import ABCMeta, abstractmethod
 
-from rdflib import Dataset, Graph
+from flask import current_app
 from rdflib.query import ResultException
 from rdflib.resource import Resource
 from rdflib.term import URIRef
-from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 
-from lakesuperior.config_parser import config
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
 from lakesuperior.dictionaries.namespaces import ns_mgr as nsm
 from lakesuperior.exceptions import ResourceNotExistsError
+from lakesuperior.store_layouts.rdf.graph_store_connector import \
+        GraphStoreConnector
 from lakesuperior.toolbox import Toolbox
 
 
-#def needs_rsrc(fn):
-#    '''
-#    Decorator for methods that cannot be called without `self.rsrc` set.
-#    '''
-#    def wrapper(self, *args, **kwargs):
-#        if not hasattr(self, 'rsrc') or self.rsrc is None:
-#            raise TypeError(
-#                'This method must be called by an instance with `rsrc` set.')
-#
-#        return fn(self, *args, **kwargs)
-#
-#    return wrapper
-
-
 
 class BaseRdfLayout(metaclass=ABCMeta):
     '''
@@ -67,12 +53,8 @@ class BaseRdfLayout(metaclass=ABCMeta):
     RES_CREATED = '_created_'
     RES_UPDATED = '_updated_'
 
-    conf = config['application']['store']['ldp_rs']
     _logger = logging.getLogger(__name__)
 
-    query_ep = conf['webroot'] + conf['query_ep']
-    update_ep = conf['webroot'] + conf['update_ep']
-
 
     ## MAGIC METHODS ##
 
@@ -82,26 +64,32 @@ class BaseRdfLayout(metaclass=ABCMeta):
         NOTE: `rdflib.Dataset` requires a RDF 1.1 compliant store with support
         for Graph Store HTTP protocol
         (https://www.w3.org/TR/sparql11-http-rdf-update/). Blazegraph supports
-        this only in the (currently) unreleased 2.2 branch. It works with Jena,
-        but other considerations would have to be made (e.g. Jena has no REST
-        API for handling transactions).
+        this only in the (currently unreleased) 2.2 branch. It works with Jena,
+        which is currently the reference implementation.
         '''
-        self.ds = Dataset(self.store, default_union=True)
-        self.ds.namespace_manager = nsm
+        self.conf = current_app.config['store']['ldp_rs']
+        self._conn = GraphStoreConnector(
+                self.conf['webroot'] + self.conf['query_ep'],
+                update_ep=self.conf['webroot'] + self.conf['update_ep'])
 
 
     @property
     def store(self):
         if not hasattr(self, '_store') or not self._store:
-            self._store = SPARQLUpdateStore(
-                    queryEndpoint=self.query_ep,
-                    update_endpoint=self.update_ep,
-                    autocommit=False,
-                    dirty_reads=True)
+            self._store = self._conn.store
 
         return self._store
 
 
+    @property
+    def ds(self):
+        if not hasattr(self, '_ds'):
+            self._ds = self._conn.ds
+            self._ds.namespace_manager = nsm
+
+        return self._ds
+
+
     @property
     def protected_pred(self):
         '''
@@ -117,36 +105,6 @@ class BaseRdfLayout(metaclass=ABCMeta):
 
     ## PUBLIC METHODS ##
 
-    def query(self, q, initBindings=None, nsc=nsc):
-        '''
-        Perform a SPARQL query on the triplestore.
-
-        This should provide non-abstract access, independent from the layout,
-        therefore it should not be overridden by individual layouts.
-
-        @param q (string) SPARQL query.
-
-        @return rdflib.query.Result
-        '''
-        self._logger.debug('Sending SPARQL query: {}'.format(q))
-        return self.ds.query(q, initBindings=initBindings, initNs=nsc)
-
-
-    def update(self, q, initBindings=None, nsc=nsc):
-        '''
-        Perform a SPARQL update on the triplestore.
-
-        This should provide low-level access, independent from the layout,
-        therefore it should not be overridden by individual layouts.
-
-        @param q (string) SPARQL-UPDATE query.
-
-        @return None
-        '''
-        self._logger.debug('Sending SPARQL update: {}'.format(q))
-        return self.ds.query(q, initBindings=initBindings, initNs=nsc)
-
-
     def rsrc(self, urn):
         '''
         Reference to a live data set that can be updated. This exposes the

lakesuperior/store_layouts/rdf/graph_store_connector.py

@@ -0,0 +1,66 @@
+import logging
+
+from rdflib import Dataset
+from rdflib.plugins.stores.sparqlstore import SPARQLStore, SPARQLUpdateStore
+from SPARQLWrapper.Wrapper import POST
+
+from lakesuperior.dictionaries.namespaces import ns_collection as nsc
+
+
+class GraphStoreConnector:
+    '''
+    Handles the connection and dataset information.
+
+    This is indpendent from the application context (production/test) and can
+    be passed any configuration options.
+    '''
+
+    _logger = logging.getLogger(__name__)
+
+    def __init__(self, query_ep, update_ep=None):
+        if update_ep:
+            self.store = SPARQLUpdateStore(
+                    queryEndpoint=query_ep,
+                    update_endpoint=update_ep,
+                    autocommit=False,
+                    dirty_reads=True)
+
+            self.readonly = False
+        else:
+            self.store = SPARQLStore(query_ep, default_query_method=POST)
+            self.readonly = True
+
+        self.ds = Dataset(self.store, default_union=True)
+
+
+    def query(self, q, initBindings=None, nsc=nsc):
+        '''
+        Perform a SPARQL query on the triplestore.
+
+        This provides non-abstract access, independent from the layout.
+
+        @param q (string) SPARQL query.
+
+        @return rdflib.query.Result
+        '''
+        self._logger.debug('Sending SPARQL query: {}'.format(q))
+        return self.ds.query(q, initBindings=initBindings, initNs=nsc)
+
+
+    def update(self, q, initBindings=None, nsc=nsc):
+        '''
+        Perform a SPARQL update on the triplestore. This is only needed for
+        low-level, optimized operations that are not well performed by the
+        higher-level methods provided by RDFLib.
+
+        This provides non-abstract access, independent from the layout.
+
+        @param q (string) SPARQL-UPDATE query.
+
+        @return None
+        '''
+        self._logger.debug('Sending SPARQL update: {}'.format(q))
+        return self.ds.query(q, initBindings=initBindings, initNs=nsc)
+
+
+

lakesuperior/store_layouts/rdf/simple_layout.py

@@ -71,7 +71,7 @@ class SimpleLayout(BaseRdfLayout):
                 embed_chld=embed_children_qry, omit_srv_mgd=srv_mgd_qry)
 
         try:
-            qres = self.query(q)
+            qres = self._conn.query(q)
         except ResultException:
             # RDFlib bug: https://github.com/RDFLib/rdflib/issues/775
             g = Graph()