Adopt orm interface in events/api.py module

solar/solar/events/api.py

@@ -18,19 +18,21 @@ __all__ = ['add_dep', 'add_react']
 import networkx as nx
 
 from solar.core.log import log
-from solar.interfaces.db import get_db
+from solar.interfaces import orm
 from solar.events.controls import Dep, React, StateChange
 
 
-db = get_db()
-
-
 def create_event(event_dict):
-    etype = event_dict.pop('etype')
+    etype = event_dict['etype']
+    kwargs = {'child': event_dict['child'],
+              'parent': event_dict['parent'],
+              'child_action': event_dict['child_action'],
+              'parent_action': event_dict['parent_action'],
+              'state': event_dict['state']}
     if etype == React.etype:
-        return React(**event_dict)
+        return React(**kwargs)
     elif etype == Dep.etype:
-        return Dep(**event_dict)
+        return Dep(**kwargs)
     else:
         raise Exception('No support for type %s', etype)
 
@@ -42,10 +44,8 @@ def add_event(ev):
             break
     else:
         rst.append(ev)
-        db.create(
+        event_db = orm.DBEvent(**ev.to_dict())
-            ev.parent_node,
+        event_db.save()
-            [i.to_dict() for i in rst],
-            collection=db.COLLECTIONS.events)
 
 
 def add_dep(parent, dep, actions, state='success'):
@@ -64,31 +64,28 @@ def add_react(parent, dep, actions, state='success'):
         log.debug('Added event: %s', r)
 
 
+def add_events(resource, lst):
+    for ev in lst:
+        event_db = orm.DBEvent(**ev.to_dict())
+        event_db.save()
+
+
 def set_events(resource, lst):
-    db.create(
+    orm.DBEvent.delete_list(resource)
-        resource,
+    add_events(resource, lst)
-        [i.to_dict() for i in lst],
-        collection=db.COLLECTIONS.events)
 
 
 def remove_event(ev):
-    rst = all_events(ev.parent_node)
+    event_db = orm.DBEvent(**ev.to_dict())
-    set_events(ev.parent_node, [it for it in rst if not it == ev])
+    event_db.delete()
-
-
-def add_events(resource, lst):
-    rst = all_events(resource)
-    rst.extend(lst)
-    set_events(resource, rst)
 
 
 def all_events(resource):
-    events = db.get(resource, collection=db.COLLECTIONS.events,
+    events = orm.DBEvent.load_list(resource)
-                    return_empty=True)
 
     if not events:
         return []
-    return [create_event(i) for i in events.properties]
+    return [create_event(i.to_dict()) for i in events]
 
 
 def bft_events_graph(start):

solar/solar/events/controls.py

@@ -36,38 +36,41 @@ class Event(object):
 
     etype = None
 
-    def __init__(self, parent_node, parent_action,
+    def __init__(self, parent, parent_action,
-                 state='', depend_node='', depend_action=''):
+                 state='', child='', child_action=''):
-        self.parent_node = parent_node
+        self.parent = parent
         self.parent_action = parent_action
         self.state = state
-        self.depend_node = depend_node
+        self.child = child
-        self.depend_action = depend_action
+        self.child_action = child_action
 
     @property
-    def parent(self):
+    def parent_node(self):
-        return '{}.{}'.format(self.parent_node, self.parent_action)
+        return '{}.{}'.format(self.parent, self.parent_action)
 
     @property
-    def dependent(self):
+    def child_node(self):
-        return '{}.{}'.format(self.depend_node, self.depend_action)
+        return '{}.{}'.format(self.child, self.child_action)
 
     def to_dict(self):
-        rst = {'etype': self.etype}
+        return {'etype': self.etype,
-        rst.update(self.__dict__)
+                'child': self.child,
-        return rst
+                'parent': self.parent,
+                'parent_action': self.parent_action,
+                'child_action': self.child_action,
+                'state': self.state}
 
     def __eq__(self, inst):
         if inst.__class__ != self.__class__:
             return False
         return all((
-            self.parent == inst.parent,
+            self.parent_node == inst.parent_node,
             self.state == inst.state,
-            self.dependent == inst.dependent))
+            self.child_node == inst.child_node))
 
     def __repr__(self):
         return '{}: {} -> {} -> {}'.format(
-            self.etype, self.parent, self.state, self.dependent)
+            self.etype, self.parent_node, self.state, self.child_node)
 
     def __hash__(self):
         return hash(repr(self))
@@ -78,10 +81,10 @@ class Dependency(Event):
     etype = 'depends_on'
 
     def insert(self, changed_resources, changes_graph):
-        if (self.parent in changes_graph and
+        if (self.parent_node in changes_graph and
-            self.dependent in changes_graph):
+            self.child_node in changes_graph):
             changes_graph.add_edge(
-                self.parent, self.dependent, state=self.state)
+                self.parent_node, self.child_node, state=self.state)
 
 Dep = Dependency
 
@@ -91,15 +94,15 @@ class React(Event):
 
     def insert(self, changed_resources, changes_graph):
 
-        if self.parent in changes_graph:
+        if self.parent_node in changes_graph:
-            if self.dependent not in changes_graph:
+            if self.child_node not in changes_graph:
                 changes_graph.add_node(
-                    self.dependent, status='PENDING',
+                    self.child_node, status='PENDING',
                     errmsg=None, type='solar_resource',
-                    args=[self.depend_node, self.depend_action])
+                    args=[self.child, self.child_action])
 
-            changes_graph.add_edge(self.parent, self.dependent, state=self.state)
+            changes_graph.add_edge(self.parent_node, self.child_node, state=self.state)
-            changed_resources.append(self.depend_node)
+            changed_resources.append(self.child)
 
 
 class StateChange(Event):
@@ -109,6 +112,6 @@ class StateChange(Event):
     def insert(self, changed_resources, changes_graph):
         changed_resources.append(self.parent)
         changes_graph.add_node(
-            self.parent, status='PENDING',
+            self.parent_node, status='PENDING',
             errmsg=None, type='solar_resource',
-            args=[self.parent_node, self.parent_action])
+            args=[self.parent, self.parent_action])

solar/solar/interfaces/db/redis_graph_db.py

@@ -152,6 +152,11 @@ class RedisGraphDB(BaseGraphDB):
         except TypeError:
             raise KeyError
 
+    def delete(self, name, collection=BaseGraphDB.DEFAULT_COLLECTION):
+        keys = self._r.keys(self._make_collection_key(collection, name))
+        if keys:
+            self._r.delete(*keys)
+
     def get_or_create(self,
                       name,
                       properties={},

solar/solar/interfaces/orm.py

@@ -382,6 +382,12 @@ class DBObject(object):
             collection=self._collection
         )
 
+    def delete(self):
+        db.delete(
+            self._db_key,
+            collection=self._collection
+        )
+
 
 class DBResourceInput(DBObject):
     __metaclass__ = DBObjectMeta
@@ -526,7 +532,7 @@ class DBEvent(DBObject):
     id = db_field(is_primary=True)
     parent = db_field(schema='str!')
     parent_action = db_field(schema='str!')
-    evtype = db_field('str!')
+    etype = db_field('str!')
     state = db_field('str')
     child = db_field('str')
     child_action = db_field('str')
@@ -536,10 +542,17 @@ class DBEvent(DBObject):
         rs = db.all(collection=cls._collection.name + ':' + parent)
         return [cls(**r.properties) for r in rs]
 
+    @classmethod
+    def delete_list(cls, parent):
+        db.delete('*', collection=cls._collection.name + ':' + parent)
+
     @property
     def _db_key(self):
         if not self._primary_field.value:
-            setattr(self, self._primary_field.name, '{}:{}'.format(self.parent, unicode(uuid.uuid4())))
+            setattr(self, self._primary_field.name,
+                    '{}:{}:{}:{}:{}'.format(
+                        self.parent, self.parent_action,
+                        self.state, self.child, self.child_action))
             self._update_fields_values()
         return DBObject._db_key.fget(self)
 

solar/solar/test/test_events.py

@@ -39,7 +39,6 @@ def test_set_events(events_example):
     partial = events_example[:2]
     evapi.add_events('e1', events_example[:2])
     evapi.set_events('e1', events_example[2:])
-
     assert evapi.all_events('e1') == events_example[2:]
 
 

solar/solar/test/test_orm.py

@@ -432,7 +432,7 @@ class TestEventORM(BaseResourceTest):
             state='success',
             child_action='run',
             child='n2',
-            evtype='dependency')
+            etype='dependency')
         ev.save()
 
         rst = orm.DBEvent.load_list('n1')
@@ -446,7 +446,7 @@ class TestEventORM(BaseResourceTest):
             state='success',
             child_action='run',
             child='n2',
-            evtype='dependency')
+            etype='dependency')
         ev.save()
         ev1 = orm.DBEvent(
             parent='n1',
@@ -454,6 +454,6 @@ class TestEventORM(BaseResourceTest):
             state='success',
             child_action='run',
             child='n3',
-            evtype='dependency')
+            etype='dependency')
         ev1.save()
         self.assertEqual(len(orm.DBEvent.load_list('n1')), 2)