Merge pull request #3 from crits/ckane-rwobj-example

ckane · web-flow · commit ae2fdc51c266 · 2018-09-29T23:16:54.000-04:00
Example of read/write and object translation
diff --git a/light/__init__.py b/light/__init__.py
@@ -6,7 +6,8 @@
 
 from gunicorn.six import iteritems
 
-from .framework import route_framework
+from .framework import route_framework, load_driver
+from . import backend
 
 
 def number_of_workers():
@@ -52,14 +53,29 @@ def main():
         default=number_of_workers(),
         help='Number of workers to boot (default: CPU_COUNT * 2 + 1)'
     )
+    parser.add_argument(
+        '-D', '--driver', type=str, dest='driver',
+        default='disk:demo_db',
+        help='Driver with store name, such as disk:<folder name> or mysql:<database name>'
+    )
 
     args = parser.parse_args()
 
+    dbdriver, dbstore = args.driver.split(':', 1)[0:2]
     options = {
         'bind': '%s:%s' % (args.host, args.port),
         'workers': args.workers,
+        'dbdriver': dbdriver,
+        'dbstore': dbstore,
     }
 
+    # Instantiate the backend driver (TODO: Make this generic and a configurable)
+    backend.current_driver = load_driver(options)
+
+    if not backend.current_driver:
+        print('Cannot find driver {d}\n'.format(d=options['dbdriver']))
+        return 1
+
     # Create a Falcon app.
     app = falcon.API()
 
diff --git a/light/backend.py b/light/backend.py
@@ -0,0 +1 @@
+current_driver = None
diff --git a/light/drivers/__init__.py b/light/drivers/__init__.py
diff --git a/light/drivers/disk.py b/light/drivers/disk.py
@@ -0,0 +1,49 @@
+import os
+import json
+import bson
+
+# A simple driver that uses a directory structure to manage
+# data objects as discrete text files containing JSON data
+
+class disk_driver(object):
+    def __init__(self, root_dir='.'):
+        self.root = root_dir
+
+        # If they provided the trailing slash, remove it
+        # for consistency
+        if self.root[-1] == '/':
+            self.root = self.root[:-1]
+
+        if not os.access('{root}'.format(root=self.root), os.W_OK):
+            os.mkdir(path='{root}'.format(root=self.root), mode=0o755)
+
+    # Indiscriminantly write the object back to disk. Overwrite any existing instance.
+    def store(self, set_name, obj):
+        if not os.access('{root}/{set_name}'.format(root=self.root, set_name=set_name), os.W_OK):
+            os.mkdir(path='{root}/{set_name}'.format(root=self.root, set_name=set_name), mode=0o755)
+        with open('{root}/{set_name}/{objid}.json'.format(root=self.root, set_name=set_name,
+                                                          objid=obj['id']), 'w') as objfh:
+            json.dump(obj, objfh)
+
+    # Given a set_name and objid, load the object identified by that objid. If it isn't present,
+    # return None
+    def load(self, set_name, objid):
+        if os.access('{root}/{set_name}/{objid}.json'.format(root=self.root, set_name=set_name,
+                                                             objid=str(objid)), os.R_OK):
+            with open('{root}/{set_name}/{objid}.json'.format(root=self.root, set_name=set_name,
+                                                              objid=str(objid)), 'r') as objfh:
+                obj = json.load(objfh)
+                return obj
+
+            return None
+
+    # Fetch all entities from a given set (given by set_name)
+    def get_all(self, set_name):
+        if not os.access('{root}/{set_name}'.format(root=self.root, set_name=set_name), os.W_OK):
+            return
+
+        with os.scandir('{root}/{set_name}'.format(root=self.root, set_name=set_name)) as dir_handle:
+            for d_ent in dir_handle:
+                if not d_ent.name.startswith('.') and d_ent.is_file():
+                    # Yields only the ObjectId portion of the name, wraps it in an ObjectId
+                    yield bson.ObjectId(d_ent.name.split('.')[0])
diff --git a/light/framework.py b/light/framework.py
@@ -9,6 +9,17 @@ def on_get(self, req, res):
         """Handles all GET requests."""
         _test_resource_get(req, res)
 
+def load_driver(options):
+    # Dynamically find db driver among installed packages, and return it if it
+    # is found
+    for importer, pkgname, ispkg in pkgutil.walk_packages(['./light/drivers']):
+        if pkgname == options['dbdriver']:
+            full_pkg_name = 'drivers.{pkgname}'.format(pkgname=pkgname)
+            module = importer.find_module(full_pkg_name).load_module(full_pkg_name)
+            cobj = getattr(module, '{pkgname}_driver'.format(pkgname=pkgname))
+            cinst = cobj(options['dbstore'])
+            return cinst
+
 def route_framework(app):
     # Instantiate the TestResource class
     test_resource = TestResource()
diff --git a/light/light_types.py b/light/light_types.py
@@ -0,0 +1,111 @@
+import bson
+from . import backend
+
+class LightField(object):
+    def __init__(self, init=None, required=False, pk=False, unique=False):
+        self.required = required
+        self.pk = pk
+        self.unique = unique
+        self.assign(init)
+        self.field_name = type(self).__name__
+
+    def val(self):
+        return self.value
+
+    def assign(self, val):
+        self.value = val
+        return val
+
+    def __str__(self):
+        return str(self.val())
+
+class LightStr(LightField):
+    def __init__(self, init=None, required=False, pk=False, unique=False):
+        super(LightStr, self).__init__(init, required, pk, unique)
+
+    def assign(self, val):
+        assert(isinstance(val, str))
+        super(LightStr, self).assign(val)
+
+class LightInt(LightField):
+    def __init__(self, init=None, required=False, pk=False, unique=False):
+        super(LightInt, self).__init__(init, required, pk, unique)
+
+    def assign(self, val):
+        assert(isinstance(val, int))
+        super(LightInt, self).assign(val)
+
+class LightBool(LightField):
+    def __init__(self, init=None, required=False, pk=False, unique=False):
+        super(LightBool, self).__init__(init, required, pk, unique)
+
+    def assign(self, val):
+        assert(isinstance(val, bool))
+        super(LightBool, self).assign(val)
+
+# A base type for a document object that, at least, matches the following
+# signature:
+#
+# obj = {
+#   "id": ObjectId()
+# }
+#
+class LightDoc(object):
+    def __init__(self, **kwargs):
+        self.special_fields = ['set_name']
+        self.valid = False
+        self.set_name = type(self).set_name
+        self.data = {}
+        self.pk = None
+
+        # Dynamically identify the defined fields from the subclass definition
+        db_fields = filter(lambda x: isinstance(getattr(type(self),x),LightField), vars(type(self)))
+        for fieldk in db_fields:
+            new_field = getattr(type(self), fieldk)
+            self.data[fieldk] = new_field.val()
+            assert(not(self.pk and new_field.pk))
+            self.pk = new_field
+
+        if 'oid' not in kwargs or kwargs['oid'] == None:
+            # If instance construction gives us a NoneType oid, then we presume
+            # to be constructing a new entitiy, so give it a brand new ObjectId
+            self.data['id'] = bson.ObjectId()
+
+            # Also, walk the rest of the args for field initializers
+            for fieldk in db_fields:
+                if fieldk in kwargs:
+                    self.data[fieldk] = type(getattr(self, fieldk))(init=kwargs[fieldk])
+                else:
+                    self.data[fieldk] = type(getattr(self, fieldk))()
+
+        else:
+            # Otherwise, we are to perform a lookup and load of the designated
+            # object
+            self.load(kwargs['oid'])
+
+    def get_all(set_name, dtype):
+        for objid in backend.current_driver.get_all(set_name=set_name):
+            yield(dtype(oid=objid))
+
+    def save(self):
+        output_data = {}
+        for obj_key in self.data:
+            output_data[obj_key] = str(self.data[obj_key])
+        backend.current_driver.store(self.set_name, output_data)
+
+    def load(self, objid):
+        input_data = backend.current_driver.load(self.set_name, objid)
+
+        # Clear the instance data
+        self.data = {}
+
+        if input_data:
+            for obj_key in input_data:
+                if obj_key == 'id':
+                    self.data[obj_key] = bson.ObjectId(input_data[obj_key])
+                else:
+                    self.data[obj_key] = input_data[obj_key]
+            self.valid = True
+        else:
+            # Invalidate if the object doesn't exist
+            self.valid = False
diff --git a/light/photons/Sources.py b/light/photons/Sources.py
@@ -1,19 +1,77 @@
 import falcon
+import json
+from bson import ObjectId
+from light.light_types import LightDoc, LightField, LightStr, LightInt, LightBool
 
 resources = ["SourceSet","SourceItem"]
 
+# A very simple entity schema that's built on top of the LightDoc and
+# contains the following additional fields:
+#
+# obj = {
+#    .....
+#    'active': boolean,
+#    'source_name': string
+#}
+#
+class Source(LightDoc):
+    set_name = 'sources'
+    source_name = LightStr(init="Test", required=True)
+    active = LightBool(init=True)
+
+    def get_all():
+        for source_obj in LightDoc.get_all(Source.set_name, Source):
+            yield source_obj
+
+    def json(self):
+        output_json = self.data
+        output_json['id'] = str(output_json['id'])
+        return output_json
+
+    def load(self, oid):
+        # First, load the content from disk into the JSON structure. This will
+        # only perform a data-conversion on the 'id' (str -> ObjectId)
+        super(Source, self).load(oid)
+
+        # XXX: It is up to you to perform any remaining data conversions to the
+        # fields managed by *this* class, here, after the initial load. Remember,
+        # set self.valid to False if the data loaded fails any validation, as the
+        # superclass load() function will have set it to True
+        #
+        # This could include loading data from within separate collections/tables/sets
+        # which represent sub-documents of this data, and which are represented as
+        # foreign keys within the core object's data fields.
+        #
+
 class SourceSet(object):
     def routes_set(self, app):
         app.add_route('/sources', self)
 
     def on_get(self, req, res):
         res.status = falcon.HTTP_200
-        res.body = ('Testing source access gets.')
+        res.body = json.dumps(list(x.json() for x in Source.get_all()))
+
+    def on_post(self, req, res):
+        if req.content_length > 0:
+            json_input = json.load(req.stream)
+            if 'active' in json_input and 'source_name' in json_input:
+                src_obj = Source(source_name=LightStr(init=json_input['source_name']), active=LightBool(init=json_input['active']))
+                src_obj.save()
+                res.body = json.dumps({'success': True, 'oid': src_obj.json()['id']})
+            else:
+                res.status = 500
+        else:
+            res.status = 500
 
 class SourceItem(object):
     def routes_set(self, app):
         app.add_route('/sources/{source}', self)
 
     def on_get(self, req, res, source):
-        res.status = falcon.HTTP_200
-        res.body = ('Testing source access gets, getting item {source}.'.format(source=source))
+        src_obj = Source(oid=source)
+        if src_obj.valid:
+            res.status = falcon.HTTP_200
+            res.body = json.dumps(src_obj.json())
+        else:
+            res.status = falcon.HTTP_500
+            res.body = json.dumps({'success': False, 'message': 'Unable to find source with id {objid}'.format(objid=source)})
diff --git a/requirements.txt b/requirements.txt
@@ -1,3 +1,4 @@
+bson
 cython
 falcon --install-option="--no-binary :all:"
 gunicorn
