X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=processor.py;h=9298e9bdfaf700026c6f2471c8b01f1198f33972;hb=6a80f4b4a5315ed9d00f2b3117a5e0d447465cda;hp=e41e3037afbec754730082669cdbe0ecc04b7ec7;hpb=a8e64cfbd773b2c1bbced816c3e452b4506cf3dc;p=electrum-server.git

diff --git a/processor.py b/processor.py
index e41e303..9298e9b 100644
--- a/processor.py
+++ b/processor.py
@@ -35,14 +35,25 @@ class Processor(threading.Thread):
         threading.Thread.__init__(self)
         self.daemon = True
         self.dispatcher = None
+        self.queue = queue.Queue()
 
     def process(self, request):
         pass
 
     def push_response(self, response):
-        print "response", response
+        #print "response", response
         self.dispatcher.request_dispatcher.push_response(response)
 
+    def run(self):
+        while not self.shared.stopped():
+            request = self.queue.get(10000000000)
+            try:
+                self.process(request)
+            except:
+                traceback.print_exc(file=sys.stdout)
+
+        print "processor terminating"
+            
 
 
 class Dispatcher:
@@ -89,6 +100,11 @@ class RequestDispatcher(threading.Thread):
     def pop_request(self):
         return self.request_queue.get()
 
+    def get_session_by_address(self, address):
+        for x in self.sessions:
+            if x.address == address:
+                return x
+
     def get_session_id(self, internal_id):
         with self.lock:
             return self.internal_ids.pop(internal_id)
@@ -105,17 +121,22 @@ class RequestDispatcher(threading.Thread):
             raise TypeError("self.shared not set in Processor")
         while not self.shared.stopped():
             session, request = self.pop_request()
-            self.process(session, request)
+            try:
+                self.do_dispatch(session, request)
+            except:
+                traceback.print_exc(file=sys.stdout)
+                
 
         self.stop()
 
     def stop(self):
         pass
 
-    def process(self, session, request):
+    def do_dispatch(self, session, request):
+        """ dispatch request to the relevant processor """
+
         method = request['method']
         params = request.get('params',[])
-
         suffix = method.split('.')[-1]
         if suffix == 'subscribe':
             session.subscribe_to_service(method, params)
@@ -123,21 +144,22 @@ class RequestDispatcher(threading.Thread):
         # store session and id locally
         request['id'] = self.store_session_id(session, request['id'])
 
-        # dispatch request to the relevant module..
         prefix = request['method'].split('.')[0]
         try:
             p = self.processors[prefix]
         except:
             print "error: no processor for", prefix
             return
-        try:
-            p.process(request)
-        except:
-            traceback.print_exc(file=sys.stdout)
+
+        p.queue.put(request)
 
         if method in ['server.version']:
             session.version = params[0]
 
+    def get_sessions(self):
+        with self.lock:
+            r = self.sessions[:]
+        return r
 
     def add_session(self, session):
         with self.lock:
@@ -164,20 +186,24 @@ class Session:
         self.subscriptions = []
         self.address = ''
         self.name = ''
-        #threading.Timer(2, self.info).start()
+        self.version = 'unknown'
+        self.time = time.time()
+        threading.Timer(2, self.info).start()
 
     # Debugging method. Doesn't need to be threadsafe.
     def info(self):
         for sub in self.subscriptions:
-            print sub
-            method, params = sub
+            #print sub
+            method = sub[0]
             if method == 'blockchain.address.subscribe':
-                addr = params[0]
+                addr = sub[1]
                 break
         else:
             addr = None
-        print (timestr(), self.name, self.address, addr,
-               len(self.subscriptions), self.version)
+
+        if self.subscriptions:
+            print timestr(), self.name, self.address, addr,\
+                len(self.subscriptions), self.version
 
     def stopped(self):
         with self.lock:
@@ -186,13 +212,17 @@ class Session:
     def subscribe_to_service(self, method, params):
         subdesc = self.build_subdesc(method, params)
         with self.lock:
-            self.subscriptions.append(subdesc)
+            if subdesc is not None:
+                self.subscriptions.append(subdesc)
 
     # subdesc = A subscription description
-    def build_subdesc(self, method, params):
+    @staticmethod
+    def build_subdesc(method, params):
         if method == "blockchain.numblocks.subscribe":
             return method,
-        elif method == "blockchain.address.get_history":
+        elif method == "blockchain.headers.subscribe":
+            return method,
+        elif method == "blockchain.address.subscribe":
             if not params:
                 return None
             else:
@@ -222,18 +252,19 @@ class ResponseDispatcher(threading.Thread):
         #print "pop response", response
         internal_id = response.get('id')
         method = response.get('method')
-        params = response.get('params', [])
+        params = response.get('params')
 
         # A notification
-        if internal_id is None and method is None:
-            self.notification(response)
-        elif internal_id is not None:
+        if internal_id is None: # and method is not None and params is not None:
+            self.notification(method, params, response)
+        # A response
+        elif internal_id is not None: # and method is None and params is None:
             self.send_response(internal_id, response)
         else:
             print "no method", response
 
-    def notification(self, response):
-        subdesc = self.build_subdesc(method, params)
+    def notification(self, method, params, response):
+        subdesc = Session.build_subdesc(method, params)
         for session in self.processor.sessions:
             if session.stopped():
                 continue
@@ -242,6 +273,9 @@ class ResponseDispatcher(threading.Thread):
 
     def send_response(self, internal_id, response):
         session, message_id = self.processor.get_session_id(internal_id)
-        response['id'] = message_id
-        session.send_response(response)
+        if session:
+            response['id'] = message_id
+            session.send_response(response)
+        else:
+            print "send_response: no session", message_id, internal_id, response