bugfix: restore method name

[electrum-server.git] / processor.py

diff --git a/processor.py b/processor.py
index 20fdbfd..749f383 100644 (file)
--- a/processor.py
+++ b/processor.py
@@ -35,6 +35,7 @@ class Processor(threading.Thread):
         threading.Thread.__init__(self)
         self.daemon = True
         self.dispatcher = None
+        self.queue = queue.Queue()
 
     def process(self, request):
         pass
@@ -43,6 +44,16 @@ class Processor(threading.Thread):
         #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:
@@ -110,39 +121,60 @@ 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]
+
+        is_new = session.protocol_version >= 0.5
+
+        if is_new and method == 'blockchain.address.get_history': 
+            method = 'blockchain.address.get_history2'
+            request['method'] = method
+
         if suffix == 'subscribe':
+            if is_new and method == 'blockchain.address.subscribe': 
+                method = 'blockchain.address.subscribe2'
+                request['method'] = method
+
             session.subscribe_to_service(method, params)
 
         # 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]
+            try:
+                session.protocol_version = float(params[1])
+            except:
+                pass
 
+    def get_sessions(self):
+        with self.lock:
+            r = self.sessions[:]
+        return r
 
     def add_session(self, session):
         with self.lock:
@@ -170,6 +202,7 @@ class Session:
         self.address = ''
         self.name = ''
         self.version = 'unknown'
+        self.protocol_version = 0.
         self.time = time.time()
         threading.Timer(2, self.info).start()
 
@@ -203,7 +236,9 @@ class Session:
     def build_subdesc(method, params):
         if method == "blockchain.numblocks.subscribe":
             return method,
-        elif method == "blockchain.address.subscribe":
+        elif method == "blockchain.headers.subscribe":
+            return method,
+        elif method in ["blockchain.address.subscribe", "blockchain.address.subscribe2"]:
             if not params:
                 return None
             else:
@@ -250,6 +285,8 @@ class ResponseDispatcher(threading.Thread):
             if session.stopped():
                 continue
             if session.contains_subscription(subdesc):
+                if response.get('method') == "blockchain.address.subscribe2":
+                    response['method'] = "blockchain.address.subscribe"
                 session.send_response(response)
 
     def send_response(self, internal_id, response):