Renew backend every filter pass, allow race in backend

chaind/adapters/fs.py

@@ -10,6 +10,7 @@ from chainqueue.store.fs import (
         IndexStore,
         CounterStore,
         )
+from chainqueue.error import BackendIntegrityError
 from shep.store.file import SimpleFileStoreFactory
 from shep.error import StateInvalid
 
@@ -21,9 +22,9 @@ logg = logging.getLogger(__name__)
 
 class ChaindFsAdapter(ChaindAdapter):
 
-    def __init__(self, chain_spec, path, cache_adapter, dispatcher, cache=None, pending_retry_threshold=0, error_retry_threshold=0, digest_bytes=32):
+    def __init__(self, chain_spec, path, cache_adapter, dispatcher, cache=None, pending_retry_threshold=0, error_retry_threshold=0, digest_bytes=32, event_callback=None):
         factory = SimpleFileStoreFactory(path).add
-        state_store = Status(factory)
+        state_store = Status(factory, allow_invalid=True, event_callback=event_callback)
         index_path = os.path.join(path, 'tx')
         index_store = IndexStore(index_path, digest_bytes=digest_bytes)
         counter_store = CounterStore(path)
@@ -42,11 +43,24 @@ class ChaindFsAdapter(ChaindAdapter):
         except StateInvalid as e:
             logg.error('I am just a simple syncer and do not know how to handle the state which the tx {} is in: {}'.format(tx_hash, e))
             return None
+        except FileNotFoundError:
+            pass
+        if v ==None:
+            raise BackendIntegrityError(tx_hash)
         return v[1]
 
 
-    def upcoming(self):
+    def upcoming(self, limit=0):
-        return self.store.upcoming()
+        real_limit = 0
+        in_flight = 0
+        if limit > 0:
+            in_flight = self.store.by_state(state=self.store.IN_NETWORK, not_state=self.store.FINAL)
+            real_limit = limit - len(in_flight)
+            if real_limit <= 0:
+                return []
+        r = self.store.upcoming(limit=real_limit)
+        logg.info('upcoming returning {} upcoming from limit {} less {} active in-flight txs'.format(len(r), limit, len(in_flight)))
+        return r
 
 
     def pending(self):
@@ -57,6 +71,10 @@ class ChaindFsAdapter(ChaindAdapter):
         return self.store.deferred()
 
 
+    def failed(self):
+        return self.store.failed()
+
+
     def succeed(self, block, tx):
         if self.store.is_reserved(tx.hash):
             raise QueueLockError(tx.hash)
@@ -68,6 +86,10 @@ class ChaindFsAdapter(ChaindAdapter):
         return self.store.final(tx.hash, block, tx, error=True)
 
 
+    def sendfail(self):
+        return self.store.fail(tx.hash)
+
+
     def enqueue(self, tx_hash):
         return self.store.enqueue(tx_hash)
 

chaind/data/config/token.ini

@@ -0,0 +1,2 @@
+[token]
+module =

chaind/filter.py

@@ -5,28 +5,57 @@ import time
 # external imports
 from chainlib.status import Status as TxStatus
 from chainsyncer.filter import SyncFilter
-from chainqueue.error import NotLocalTxError
+from chainqueue.error import (
+        NotLocalTxError,
+        BackendIntegrityError,
+        )
+from chaind.adapters.fs import ChaindFsAdapter
 
 # local imports
 from .error import QueueLockError
 
 logg = logging.getLogger(__name__)
 
+
 class StateFilter(SyncFilter):
 
     delay_limit = 3.0
 
-    def __init__(self, adapter, throttler=None):
+    def __init__(self, chain_spec, adapter_path, tx_adapter, throttler=None):
-        self.adapter = adapter
+        self.chain_spec = chain_spec
+        self.adapter_path = adapter_path
+        self.tx_adapter = tx_adapter
         self.throttler = throttler
 
 
     def filter(self, conn, block, tx, session=None):
-        try:
+        cache_tx = None
-            cache_tx = self.adapter.get(tx.hash)
+        for i in range(3):
-        except NotLocalTxError:
+            queue_adapter = None
-            logg.debug('skipping not local transaction {}'.format(tx.hash))
+            try:
-            return False
+                queue_adapter = ChaindFsAdapter(
+                    self.chain_spec,
+                    self.adapter_path,
+                    self.tx_adapter,
+                    None,
+                    )
+            except BackendIntegrityError as e:
+                logg.error('adapter instantiation failed: {}, one more try'.format(e))
+                continue
+
+            try:
+                cache_tx = queue_adapter.get(tx.hash)
+            except NotLocalTxError:
+                logg.debug('skipping not local transaction {}'.format(tx.hash))
+                return False
+            except BackendIntegrityError as e:
+                logg.error('adapter instantiation failed: {}, one more try'.format(e))
+                continue
+
+            break
+
+        if cache_tx == None:
+            raise NotLocalTxError(tx.hash)
 
         delay = 0.01
         while True:
@@ -34,9 +63,9 @@ class StateFilter(SyncFilter):
                 raise QueueLockError('The queue lock for tx {} seems to be stuck. Human meddling needed.'.format(tx.hash))
             try:
                 if tx.status == TxStatus.SUCCESS:
-                    self.adapter.succeed(block, tx)
+                    queue_adapter.succeed(block, tx)
                 else:
-                    self.adapter.fail(block, tx)
+                    queue_adapter.fail(block, tx)
                 break
             except QueueLockError as e:
                 logg.debug('queue item {} is blocked, will retry: {}'.format(tx.hash, e))

chaind/session.py

@@ -104,7 +104,6 @@ class SessionController:
             logg.error('invalid input "{}"'.format(data_in_str))
             raise ClientInputError()
 
-        logg.info('recv {} bytes'.format(len(data)))
         return (srvs, data,)
 
 

chaind/unittest/common.py

@@ -1,5 +1,4 @@
 # standard imports
-import unittest
 import hashlib
 import tempfile
 
@@ -9,9 +8,6 @@ from chainlib.status import Status as TxStatus
 from chainlib.chain import ChainSpec
 from chainlib.error import RPCException
 
-# local imports
-from chaind.adapters.fs import ChaindFsAdapter
-
 
 class MockCacheAdapter(CacheTokenTx):
 
@@ -33,7 +29,9 @@ class MockDispatcher:
 
 
     def send(self, v):
-        if v not in self.fails:
+        import sys
+        sys.stderr.write('susu v {} {}\n'.format(v, self.fails))
+        if v in self.fails:
             raise RPCException('{} is in fails'.format(v))
         pass
 
@@ -43,12 +41,3 @@ class MockTx:
     def __init__(self, tx_hash, status=TxStatus.SUCCESS):
         self.hash = tx_hash
         self.status = status
-
-
-class TestChaindFsBase(unittest.TestCase):
-
-    def setUp(self):
-        self.chain_spec = ChainSpec('foo', 'bar', 42, 'baz')
-        self.path = tempfile.mkdtemp()
-        self.adapter = ChaindFsAdapter(self.chain_spec, self.path, self.cache_adapter, self.dispatcher)
-

chaind/unittest/fs.py

@@ -0,0 +1,31 @@
+# standard imports
+import unittest
+import tempfile
+import logging
+
+# external imports
+from chainlib.chain import ChainSpec
+
+# local imports
+from chaind.adapters.fs import ChaindFsAdapter
+
+logging.STATETRACE = 5
+logg = logging.getLogger(__name__)
+logg.setLevel(logging.STATETRACE)
+
+
+class TestChaindFsBase(unittest.TestCase):
+
+    def setUp(self):
+        self.chain_spec = ChainSpec('foo', 'bar', 42, 'baz')
+        self.path = tempfile.mkdtemp()
+        self.adapter = ChaindFsAdapter(self.chain_spec, self.path, self.cache_adapter, self.dispatcher, event_callback=self.log_state)
+
+
+    def log_state(self, k, from_state, to_state):
+        logg.log(logging.STATETRACE, 'state change {}: {} -> {}'.format(
+            k,
+            from_state,
+            to_state,
+            )
+            )

requirements.txt

@@ -1,6 +1,6 @@
 chainlib~=0.1.1
-chainqueue~=0.1.5
+chainqueue~=0.1.6
-chainsyncer~=0.4.2
+chainsyncer~=0.4.3
 confini~=0.6.0
 funga~=0.5.2
 pyxdg~=0.26

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = chaind
-version = 0.1.3
+version = 0.2.0
 description = Base package for chain queue service
 author = Louis Holbrook
 author_email = dev@holbrook.no

tests/test_fs.py

@@ -15,15 +15,14 @@ from chaind.filter import StateFilter
 from chaind.unittest.common import (
     MockTx,
     MockCacheAdapter,
-    TestChaindFsBase,
+    MockDispatcher,
     )
-
+from chaind.unittest.fs import TestChaindFsBase
 
 logging.basicConfig(level=logging.DEBUG)
 logg = logging.getLogger()
 
 
-
 class TestChaindFs(TestChaindFsBase):
 
     def setUp(self):
@@ -43,12 +42,15 @@ class TestChaindFs(TestChaindFsBase):
         self.assertEqual(data, v)
 
 
-    def test_fs_defer(self):
+    def test_fs_fail(self):
         data = os.urandom(128).hex()
         hsh = self.adapter.put(data)
-        self.dispatcher.add_fail(hsh)
+        self.dispatcher.add_fail(data)
-        self.adapter.dispatch(hsh)
+
-        txs = self.adapter.deferred()
+        r = self.adapter.dispatch(hsh)
+        self.assertFalse(r)
+
+        txs = self.adapter.failed()
         self.assertEqual(len(txs), 1)
 
 
@@ -88,5 +90,25 @@ class TestChaindFs(TestChaindFsBase):
         fltr.filter(None, None, tx)
 
 
+    def test_upcoming(self):
+        drv = QueueDriver(self.adapter)
+
+        txs = []
+        for i in range(10):
+            data = os.urandom(128).hex()
+            hsh = self.adapter.put(data)
+            txs.append(hsh)
+            self.adapter.enqueue(hsh)
+
+        r = self.adapter.upcoming(limit=5)
+        self.assertEqual(len(r), 5)
+
+        r = self.adapter.dispatch(txs[0])
+        self.assertTrue(r)
+
+        r = self.adapter.upcoming(limit=5)
+        self.assertEqual(len(r), 4)
+
+
 if __name__ == '__main__':
     unittest.main()