Add new env files.

lakesuperior/env.py

@@ -0,0 +1,21 @@
+import threading
+
+'''
+Thread-local bucket for switching configuration. Different environments
+(e.g. webapp, test suite) put the appropriate value in it.
+The most important values to be stored are app_conf (either from
+lakesuperior.config_parser.config or lakesuperior.config_parser.test_config)
+and app_globals (obtained by an instance of lakesuperior.globals.AppGlobals).
+
+e.g.:
+
+>>> from lakesuperior.config_parser import config
+>>> from lakesuperior.globals import AppGlobals
+>>> from lakesuperior.env import env
+>>> env.config = config
+>>> env.app_globals = AppGlobals(config)
+
+This is automated in non-test environments by importing
+`lakesuperior.env_setup`.
+'''
+env = threading.local()

lakesuperior/env_setup.py

@@ -0,0 +1,9 @@
+from lakesuperior.config_parser import config
+from lakesuperior.globals import AppGlobals
+from lakesuperior.env import env
+
+'''
+Import this module to initialize the configuration for a production setup.
+'''
+env.config = config
+env.app_globals = AppGlobals(config)

lakesuperior/globals.py

@@ -0,0 +1,78 @@
+import logging
+
+from collections import deque
+from importlib import import_module
+from logging.config import dictConfig
+
+'''
+Constants used in messaging to identify an event type.
+'''
+RES_CREATED = '_create_'
+RES_DELETED = '_delete_'
+RES_UPDATED = '_update_'
+
+
+class AppGlobals:
+    '''
+    Application Globals.
+
+    This class sets up all connections and exposes them across the application
+    outside of the Flask app context.
+    '''
+    def __init__(self, conf):
+        from lakesuperior.messaging.messenger import Messenger
+
+        app_conf = conf['application']
+
+        # Initialize RDF layout.
+        rdfly_mod_name = app_conf['store']['ldp_rs']['layout']
+        rdfly_mod = import_module('lakesuperior.store.ldp_rs.{}'.format(
+                rdfly_mod_name))
+        rdfly_cls = getattr(rdfly_mod, self.camelcase(rdfly_mod_name))
+        #logger.info('RDF layout: {}'.format(rdfly_mod_name))
+
+        # Initialize file layout.
+        nonrdfly_mod_name = app_conf['store']['ldp_nr']['layout']
+        nonrdfly_mod = import_module('lakesuperior.store.ldp_nr.{}'.format(
+                nonrdfly_mod_name))
+        nonrdfly_cls = getattr(nonrdfly_mod, self.camelcase(nonrdfly_mod_name))
+        #logger.info('Non-RDF layout: {}'.format(nonrdfly_mod_name))
+
+        # Set up messaging.
+        messenger = Messenger(app_conf['messaging'])
+
+        # Exposed globals.
+        self._rdfly = rdfly_cls(app_conf['store']['ldp_rs'])
+        self._nonrdfly = nonrdfly_cls(app_conf['store']['ldp_nr'])
+        self._messenger = messenger
+        self._changelog = deque()
+
+
+    @property
+    def rdfly(self):
+        return self._rdfly
+
+    @property
+    def rdf_store(self):
+        return self._rdfly.store
+
+    @property
+    def nonrdfly(self):
+        return self._nonrdfly
+
+    @property
+    def messenger(self):
+        return self._messenger
+
+    @property
+    def changelog(self):
+        return self._changelog
+
+
+    def camelcase(self, word):
+        '''
+        Convert a string with underscores to a camel-cased one.
+
+        Ripped from https://stackoverflow.com/a/6425628
+        '''
+        return ''.join(x.capitalize() or '_' for x in word.split('_'))

util/benchmark.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+import sys
+sys.path.append('.')
+
+from uuid import uuid4
+
+import arrow
+import requests
+
+from rdflib import Graph, URIRef, Literal
+
+from util.generators import random_utf8_string
+
+
+default_n = 10000
+webroot = 'http://localhost:8000/ldp'
+#webroot = 'http://localhost:8080/rest'
+container_uri = webroot + '/pomegranate'
+
+sys.stdout.write('How many children? [{}] >'.format(default_n))
+choice = input().lower()
+n = int(choice) if choice else default_n
+
+sys.stdout.write('Delete container? [n] >')
+choice = input().lower()
+del_cont = choice or 'n'
+
+sys.stdout.write('POST or PUT? [PUT] >')
+choice = input().lower()
+if choice and choice.lower() not in ('post', 'put'):
+    raise ValueError('Not a valid verb.')
+method = choice.lower() or 'put'
+
+# Generate 10,000 children of root node.
+
+if del_cont  == 'y':
+    requests.delete(container_uri, headers={'prefer': 'no-tombstone'})
+requests.put(container_uri)
+
+
+start = arrow.utcnow()
+ckpt = start
+
+print('Inserting {} children.'.format(n))
+
+# URI used to establish an in-repo relationship.
+prev_uri = container_uri
+size = 50 # Size of graph to be multiplied by 4.
+
+try:
+    for i in range(1, n):
+        url = '{}/{}'.format(container_uri, uuid4()) if method == 'put' \
+                else container_uri
+
+        # Generate synthetic graph.
+        #print('generating graph: {}'.format(i))
+        g = Graph()
+        for ii in range(size):
+            g.add((
+                URIRef(''),
+                URIRef('urn:inturi_p:{}'.format(ii % size)),
+                URIRef(prev_uri)
+            ))
+            g.add((
+                URIRef(''),
+                URIRef('urn:lit_p:{}'.format(ii % size)),
+                Literal(random_utf8_string(64))
+            ))
+            g.add((
+                URIRef(''),
+                URIRef('urn:lit_p:{}'.format(ii % size)),
+                Literal(random_utf8_string(64))
+            ))
+            g.add((
+                URIRef(''),
+                URIRef('urn:exturi_p:{}'.format(ii % size)),
+                URIRef('http://exmple.edu/res/{}'.format(ii // 10))
+            ))
+
+        # Send request.
+        rsp = requests.request(
+                method, url, data=g.serialize(format='ttl'),
+                headers={ 'content-type': 'text/turtle'})
+        rsp.raise_for_status()
+        prev_uri = rsp.headers['location']
+        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()/i))