storage: wait no tid is locked in the range being checked

neo/storage/app.py

@@ -338,9 +338,9 @@ class Application(object):
             if not node.isHidden():
                 break
 
-    def queueEvent(self, some_callable, conn, args, key=None,
+    def queueEvent(self, some_callable, conn=None, args=(), key=None,
             raise_on_duplicate=True):
-        msg_id = conn.getPeerId()
+        msg_id = None if conn is None else conn.getPeerId()
         event_queue_dict = self.event_queue_dict
         if raise_on_duplicate and key in event_queue_dict:
             raise AlreadyPendingError()
@@ -362,8 +362,9 @@ class Application(object):
                 event_queue_dict[key] -= 1
                 if event_queue_dict[key] == 0:
                     del event_queue_dict[key]
-            if conn.isClosed():
-                continue
+            if conn is None:
+                some_callable(*args)
+            elif not conn.isClosed():
                 orig_msg_id = conn.getPeerId()
                 try:
                     conn.setPeerId(msg_id)

neo/storage/checker.py

@@ -104,11 +104,16 @@ class Checker(object):
         self.next_oid = None
         self.partition = partition
         self.source = source
+        def start():
+            if app.tm.isLockedTid(max_tid):
+                app.queueEvent(start)
+                return
             args = partition, CHECK_COUNT, min_tid, max_tid
             p = Packets.AskCheckTIDRange(*args)
             for conn, identified in self.conn_dict.items():
                 self.conn_dict[conn] = conn.ask(p) if identified else None
             self.conn_dict[None] = app.dm.checkTIDRange(*args)
+        start()
 
     def connected(self, node):
         conn = node.getConnection()

neo/storage/handlers/storage.py

@@ -144,29 +144,36 @@ class StorageOperationHandler(EventHandler):
 
     @checkFeedingConnection(check=True)
     def askCheckTIDRange(self, conn, *args):
+        app = self.app
+        if app.tm.isLockedTid(args[3]): # max_tid
+            app.queueEvent(self.askCheckTIDRange, conn, args)
+            return
         msg_id = conn.getPeerId()
         conn = weakref.proxy(conn)
         def check():
-            r = self.app.dm.checkTIDRange(*args)
+            r = app.dm.checkTIDRange(*args)
             try:
                 conn.answer(Packets.AnswerCheckTIDRange(*r), msg_id)
             except (weakref.ReferenceError, ConnectorConnectionClosedException):
                 pass
             yield
-        self.app.newTask(check())
+        app.newTask(check())
 
     @checkFeedingConnection(check=True)
     def askCheckSerialRange(self, conn, *args):
+        app = self.app
+        if app.tm.isLockedTid(args[3]): # max_tid
+            raise ProtocolError("transactions must be checked before objects")
         msg_id = conn.getPeerId()
         conn = weakref.proxy(conn)
         def check():
-            r = self.app.dm.checkSerialRange(*args)
+            r = app.dm.checkSerialRange(*args)
             try:
                 conn.answer(Packets.AnswerCheckSerialRange(*r), msg_id)
             except (weakref.ReferenceError, ConnectorConnectionClosedException):
                 pass
             yield
-        self.app.newTask(check())
+        app.newTask(check())
 
     @checkFeedingConnection(check=False)
     def askFetchTransactions(self, conn, partition, length, min_tid, max_tid,