Update deps

CHANGELOG

@@ -1,3 +1,5 @@
+* 0.3.2
+	- Implement rocksdb backend
 * 0.3.1
 	- Upgrade to release shep version
 	- Move sync state to SYNC after start

chainsyncer/store/base.py

@@ -1,4 +1,5 @@
 # standard imports
+import os
 import logging
 
 # local imports
@@ -145,7 +146,7 @@ class SyncItem:
 
 class SyncStore:
 
-    def __init__(self, session_id=None):
+    def __init__(self, path, session_id=None):
         self.session_id = None
         self.session_path = None
         self.is_default = False
@@ -155,6 +156,16 @@ class SyncStore:
         self.item_keys = []
         self.started = False
         self.thresholds = []
+        self.default_path = os.path.join(path, 'default')
+
+        if session_id == None:
+            self.session_path = os.path.realpath(self.default_path)
+            self.is_default = True
+        else:
+            if session_id == 'default':
+                self.is_default = True
+            given_path = os.path.join(path, session_id)
+            self.session_path = os.path.realpath(given_path)
 
 
     def setup_sync_state(self, factory, event_callback):
@@ -217,8 +228,6 @@ class SyncStore:
             state_bytes = sync_state_serialize(item.cursor, 0, -1)
             self.state.put(str(item.cursor), state_bytes)
 
-        logg.debug('item {}'.format(self.state.state(item.state_key)))
-
 
     def load(self, target):
         self.state.sync(self.state.NEW)

chainsyncer/store/fs.py

@@ -18,18 +18,7 @@ logg = logging.getLogger(__name__)
 class SyncFsStore(SyncStore):
 
     def __init__(self, base_path, session_id=None, state_event_callback=None, filter_state_event_callback=None):
-        super(SyncFsStore, self).__init__(session_id=session_id)
-
-        default_path = os.path.join(base_path, 'default')
-
-        if session_id == None:
-            self.session_path = os.path.realpath(default_path)
-            self.is_default = True
-        else:
-            if session_id == 'default':
-                self.is_default = True
-            given_path = os.path.join(base_path, session_id)
-            self.session_path = os.path.realpath(given_path)
+        super(SyncFsStore, self).__init__(base_path, session_id=session_id)
 
         create_path = False
         try:
@@ -38,9 +27,9 @@ class SyncFsStore(SyncStore):
             create_path = True
 
         if create_path:
-            self.__create_path(base_path, default_path, session_id=session_id)
-        self.session_id = os.path.basename(self.session_path)
+            self.__create_path(base_path, self.default_path, session_id=session_id)
 
+        self.session_id = os.path.basename(self.session_path)
         logg.info('session id {} resolved {} path {}'.format(session_id, self.session_id, self.session_path))
 
         base_sync_path = os.path.join(self.session_path, 'sync')

chainsyncer/store/rocksdb.py

@@ -0,0 +1,66 @@
+# standard imports
+import uuid
+import os
+import logging
+
+# external imports
+from shep.store.rocksdb import RocksDbStoreFactory
+
+# local imports 
+from chainsyncer.store import (
+        SyncItem,
+        SyncStore,
+        )
+
+logg = logging.getLogger(__name__)
+
+
+class RocksDbStoreAdder:
+
+    def __init__(self, factory, prefix):
+        self.factory = factory
+        self.prefix = prefix
+
+
+    def add(self, k):
+        path = os.path.join(self.prefix, k)
+        return self.factory.add(path)
+
+
+    def ls(self):
+        return self.factory.ls()
+
+
+class SyncRocksDbStore(SyncStore):
+
+    def __init__(self, base_path, session_id=None, state_event_callback=None, filter_state_event_callback=None):
+        super(SyncRocksDbStore, self).__init__(base_path, session_id=session_id)
+
+        self.factory = RocksDbStoreFactory(self.session_path, binary=True)
+        prefix_factory = RocksDbStoreAdder(self.factory, 'sync')
+        self.setup_sync_state(prefix_factory, state_event_callback)
+
+        prefix_factory = RocksDbStoreAdder(self.factory, 'filter')
+        self.setup_filter_state(prefix_factory, filter_state_event_callback)
+
+        self.session_id = os.path.basename(self.session_path)
+        logg.info('session id {} resolved {} path {}'.format(session_id, self.session_id, self.session_path))
+
+        self.target_db = RocksDbStoreAdder(self.factory, '.stat').add('target')
+
+
+    def get_target(self):
+        v = self.target_db.get('target')
+        if v != None:
+            self.target = int(v)
+
+
+    def set_target(self, v):
+        self.target_db.put('target', str(v))
+        self.target = v
+
+
+    def stop(self, item):
+        if item != None:
+            super(SyncRocksDbStore, self).stop(item)
+        self.factory.close()

chainsyncer/unittest/base.py

@@ -267,3 +267,12 @@ class MockChainInterfaceConn(MockConn):
 
     def handle_receipt(self, hsh):
         return {}
+
+
+class MockItem:
+
+    def __init__(self, target, offset, cursor, state_key):
+        self.target = target
+        self.offset = offset
+        self.cursor = cursor
+        self.state_key = state_key

chainsyncer/unittest/db.py

@@ -1,64 +0,0 @@
-# standard imports
-import logging
-import os
-
-# external imports
-import alembic
-import alembic.config
-
-# local imports
-from chainsyncer.db.models.base import SessionBase
-from chainsyncer.db import dsn_from_config
-from chainsyncer.db.models.base import SessionBase
-
-logg = logging.getLogger(__name__)
-
-
-class ChainSyncerDb:
-    """SQLITE database setup for unit tests
-
-    :param debug: Activate sql level debug (outputs sql statements)
-    :type debug: bool
-    """
-
-    base = SessionBase
-
-    def __init__(self, debug=False):
-        config = {
-            'DATABASE_ENGINE': 'sqlite',
-            'DATABASE_DRIVER': 'pysqlite',
-            'DATABASE_NAME': 'chainsyncer.sqlite',
-                }
-        logg.debug('config {}'.format(config))
-
-        self.dsn = dsn_from_config(config)
-
-        self.base.poolable = False
-        self.base.transactional = False
-        self.base.procedural = False
-        self.base.connect(self.dsn, debug=debug) # TODO: evaluates to "true" even if string is 0
-
-        rootdir = os.path.join(os.path.dirname(os.path.dirname(__file__)), '..')
-        dbdir = os.path.join(rootdir, 'chainsyncer', 'db')
-        #migrationsdir = os.path.join(dbdir, 'migrations', config.get('DATABASE_ENGINE'))
-        migrationsdir = os.path.join(dbdir, 'migrations', 'default')
-        logg.info('using migrations directory {}'.format(migrationsdir))
-
-        ac = alembic.config.Config(os.path.join(migrationsdir, 'alembic.ini'))
-        ac.set_main_option('sqlalchemy.url', self.dsn)
-        ac.set_main_option('script_location', migrationsdir)
-
-        alembic.command.downgrade(ac, 'base')
-        alembic.command.upgrade(ac, 'head')
-
-
-    def bind_session(self, session=None):
-        """Create session using underlying session base
-        """
-        return self.base.bind_session(session)
-
-    
-    def release_session(self, session=None):
-        """Release session using underlying session base
-        """
-        return self.base.release_session(session)

chainsyncer/unittest/store.py

@@ -1,13 +1,12 @@
 # standard imports
-import unittest
-import tempfile
-import shutil
-import logging
-import stat
 import os
+import stat
+import unittest
+import shutil
+import tempfile
+import logging
 
 # local imports
-from chainsyncer.store.fs import SyncFsStore
 from chainsyncer.session import SyncSession
 from chainsyncer.error import (
         LockError,
@@ -15,24 +14,48 @@ from chainsyncer.error import (
         IncompleteFilterError,
         SyncDone,
         )
-from chainsyncer.unittest import MockFilter
+from chainsyncer.unittest import (
+        MockFilter,
+        MockItem,
+        )
 
-logging.basicConfig(level=logging.DEBUG)
-logg = logging.getLogger()
+logg = logging.getLogger(__name__)
 
 
-class TestFs(unittest.TestCase):
+class TestStoreBase(unittest.TestCase):
 
     def setUp(self):
         self.path = tempfile.mkdtemp()
+        self.store_factory = None
+
+
+    @classmethod
+    def link(cls, target):
+        for v in [
+                "default",
+                "store_start",
+                "store_resume",
+                "sync_process_nofilter",
+                "sync_process_onefilter",
+                "sync_process_outoforder",
+                "sync_process_interrupt",
+                "sync_process_reset",
+                "sync_process_done",
+                "sync_head_future",
+                "sync_history_interrupted",
+                "sync_history_complete",
+                ]:
+            setattr(target, 'test_' + v, getattr(cls, 't_' + v))
 
 
     def tearDown(self):
         shutil.rmtree(self.path)
 
 
-    def test_default(self):
-        store = SyncFsStore(self.path)
+    def t_default(self):
+        bogus_item = MockItem(0, 0, 0, 0)
+        store = self.store_factory()
+        
         fp = os.path.join(self.path, store.session_id)
         session_id = store.session_id
         st = os.stat(fp)
@@ -47,42 +70,47 @@ class TestFs(unittest.TestCase):
         fpd = os.path.realpath(fpd)
         self.assertEqual(fpd, fp)
 
-        store = SyncFsStore(self.path)
+        store.stop(bogus_item)
+        store = self.store_factory()
         fpr = os.path.join(self.path, session_id)
         self.assertEqual(fp, fpr)
         self.assertTrue(store.is_default)
 
-        store = SyncFsStore(self.path, 'default')
+        store.stop(bogus_item)
+        store = self.store_factory('default')
         fpr = os.path.join(self.path, session_id)
         self.assertEqual(fp, fpr)
         self.assertTrue(store.is_default)
 
-        store = SyncFsStore(self.path, 'foo')
+        store.stop(bogus_item)
+        store = self.store_factory('foo')
         fpf = os.path.join(self.path, 'foo')
         st = os.stat(fpf)
         self.assertTrue(stat.S_ISDIR(st.st_mode))
         self.assertFalse(store.is_default)
 
 
-    def test_store_start(self):
-        store = SyncFsStore(self.path)
+    def t_store_start(self):
+        bogus_item = MockItem(0, 0, 0, 0)
+        store = self.store_factory()
         store.start(42)
         self.assertTrue(store.first)
 
-        store = SyncFsStore(self.path)
+        store.stop(bogus_item)
+        store = self.store_factory()
         store.start()
         self.assertFalse(store.first)
 
 
-    def test_store_resume(self):
-        store = SyncFsStore(self.path)
+    def t_store_resume(self):
+        store = self.store_factory()
         store.start(13)
         self.assertTrue(store.first)
         # todo not done
 
 
-    def test_sync_process_nofilter(self):
-        store = SyncFsStore(self.path)
+    def t_sync_process_nofilter(self):
+        store = self.store_factory()
         session = SyncSession(store)
         session.start()
         o = session.get(0)
@@ -90,8 +118,8 @@ class TestFs(unittest.TestCase):
             o.advance()
 
 
-    def test_sync_process_onefilter(self):
-        store = SyncFsStore(self.path)
+    def t_sync_process_onefilter(self):
+        store = self.store_factory()
         session = SyncSession(store)
 
         fltr_one = MockFilter('foo')
@@ -103,8 +131,8 @@ class TestFs(unittest.TestCase):
         o.release()
 
 
-    def test_sync_process_outoforder(self):
-        store = SyncFsStore(self.path)
+    def t_sync_process_outoforder(self):
+        store = self.store_factory()
         session = SyncSession(store)
 
         fltr_one = MockFilter('foo')
@@ -126,8 +154,8 @@ class TestFs(unittest.TestCase):
         o.release()
 
 
-    def test_sync_process_interrupt(self):
-        store = SyncFsStore(self.path)
+    def t_sync_process_interrupt(self):
+        store = self.store_factory()
         session = SyncSession(store)
 
         fltr_one = MockFilter('foo')
@@ -143,8 +171,8 @@ class TestFs(unittest.TestCase):
             o.advance()
 
 
-    def test_sync_process_reset(self):
-        store = SyncFsStore(self.path)
+    def t_sync_process_reset(self):
+        store = self.store_factory()
         session = SyncSession(store)
 
         fltr_one = MockFilter('foo')
@@ -170,8 +198,8 @@ class TestFs(unittest.TestCase):
         o.reset()
 
     
-    def test_sync_process_done(self):
-        store = SyncFsStore(self.path)
+    def t_sync_process_done(self):
+        store = self.store_factory()
         session = SyncSession(store)
 
         fltr_one = MockFilter('foo')
@@ -188,8 +216,8 @@ class TestFs(unittest.TestCase):
             o.next(advance_block=True)
 
 
-    def test_sync_head_future(self):
-        store = SyncFsStore(self.path, session_id='foo')
+    def t_sync_head_future(self):
+        store = self.store_factory('foo')
         session = SyncSession(store)
 
         session.start()
@@ -198,13 +226,14 @@ class TestFs(unittest.TestCase):
         o.next(advance_block=True)
         session.stop(o)
 
-        store = SyncFsStore(self.path, session_id='foo')
+        store = self.store_factory('foo')
         store.start()
         o = store.get(2)
 
 
-    def test_sync_history_interrupted(self):
-        store = SyncFsStore(self.path, session_id='foo')
+    def t_sync_history_interrupted(self):
+        bogus_item = MockItem(0, 0, 0, 0)
+        store = self.store_factory('foo')
         session = SyncSession(store)
 
         session.start(target=13)
@@ -213,7 +242,8 @@ class TestFs(unittest.TestCase):
         o.next(advance_block=True)
         session.stop(o)
 
-        store = SyncFsStore(self.path, session_id='foo')
+        store.stop(bogus_item)
+        store = self.store_factory('foo')
         store.start()
         o = store.get(0)
         self.assertEqual(o.cursor, 2)
@@ -221,15 +251,15 @@ class TestFs(unittest.TestCase):
         o.next(advance_block=True)
         o.next(advance_block=True)
 
-        session.stop(o)
-        store = SyncFsStore(self.path, session_id='foo')
+        store.stop(bogus_item)
+        store = self.store_factory('foo')
         store.start()
         self.assertEqual(o.cursor, 4)
         self.assertEqual(o.target, 13) 
 
 
-    def test_sync_history_complete(self):
-        store = SyncFsStore(self.path, session_id='foo')
+    def t_sync_history_complete(self):
+        store = self.store_factory('foo')
         session = SyncSession(store)
 
         session.start(target=3)
@@ -239,7 +269,3 @@ class TestFs(unittest.TestCase):
         o.next(advance_block=True)
         with self.assertRaises(SyncDone):
             o.next(advance_block=True)
-
-
-if __name__ == '__main__':
-    unittest.main()

requirements.txt

@@ -1,5 +1,5 @@
 confini~=0.6.0
 semver==2.13.0
 hexathon~=0.1.5
-chainlib>=0.1.0b1,<=0.1.0
-shep>=0.2.0rc1,<0.3.0
+chainlib>=0.1.0b1,<0.2.0
+shep>=0.2.1rc1,<0.3.0

run_tests.sh

@@ -8,5 +8,12 @@ for f in `ls tests/*.py`; do
 		exit
 	fi
 done
+
+for f in `ls tests/store/*.py`; do
+	python $f
+	if [ $? -gt 0 ]; then
+		exit
+	fi
+done
 set +x
 set +e

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = chainsyncer
-version = 0.3.1
+version = 0.3.2
 description = Generic blockchain syncer driver
 author = Louis Holbrook
 author_email = dev@holbrook.no
@@ -28,7 +28,6 @@ packages =
 	chainsyncer.driver
 	chainsyncer.unittest
 	chainsyncer.store
-	chainsyncer.state
 
 #[options.package_data]
 #* =

tests/store/test_1_fs.py

@@ -0,0 +1,32 @@
+# standard imports
+import unittest
+import logging
+
+# local imports
+from chainsyncer.store.fs import SyncFsStore
+from chainsyncer.unittest.store import TestStoreBase
+
+logging.basicConfig(level=logging.DEBUG)
+logg = logging.getLogger()
+
+
+class StoreFactory:
+
+    def __init__(self, path):
+        self.path = path
+
+
+    def create(self, session_id=None):
+        return SyncFsStore(self.path, session_id=session_id)
+
+
+class TestFs(TestStoreBase):
+
+    def setUp(self):
+        super(TestFs, self).setUp()
+        self.store_factory = StoreFactory(self.path).create
+
+
+if __name__ == '__main__':
+    TestStoreBase.link(TestFs)
+    unittest.main()

tests/store/test_rocksdb.py

@@ -0,0 +1,31 @@
+# standard imports
+import unittest
+import logging
+
+# local imports
+from chainsyncer.store.rocksdb import SyncRocksDbStore
+from chainsyncer.unittest.store import TestStoreBase
+
+logging.basicConfig(level=logging.DEBUG)
+logg = logging.getLogger()
+
+class StoreFactory:
+
+    def __init__(self, path):
+        self.path = path
+
+
+    def create(self, session_id=None):
+        return SyncRocksDbStore(self.path, session_id=session_id)
+
+
+class TestRocksDb(TestStoreBase):
+
+    def setUp(self):
+        super(TestRocksDb, self).setUp()
+        self.store_factory = StoreFactory(self.path).create
+
+
+if __name__ == '__main__':
+    TestStoreBase.link(TestRocksDb)
+    unittest.main()