Merge pull request #3 from fsb4000/master

[electrum-server.git] / server.py

diff --git a/server.py b/server.py
index 3b3dfc0..2a504a1 100755 (executable)
--- a/server.py
+++ b/server.py
@@ -24,6 +24,7 @@ import threading
 import traceback
 
 import json
+import os
 
 logging.basicConfig()
 
@@ -46,10 +47,10 @@ def create_config():
     config.set('server', 'banner', 'Welcome to Electrum!')
     config.set('server', 'host', 'localhost')
     config.set('server', 'report_host', '')
-    config.set('server', 'stratum_tcp_port', '50001')
-    config.set('server', 'stratum_http_port', '8081')
-    config.set('server', 'stratum_tcp_ssl_port', '')
-    config.set('server', 'stratum_http_ssl_port', '')
+    config.set('server', 'stratum_tcp_port', '40001')
+    config.set('server', 'stratum_http_port', '7081')
+    config.set('server', 'stratum_tcp_ssl_port', '40002')
+    config.set('server', 'stratum_http_ssl_port', '7082')
     config.set('server', 'report_stratum_tcp_port', '')
     config.set('server', 'report_stratum_http_port', '')
     config.set('server', 'report_stratum_tcp_ssl_port', '')
@@ -59,13 +60,13 @@ def create_config():
     config.set('server', 'password', '')
     config.set('server', 'irc', 'no')
     config.set('server', 'irc_nick', '')
-    config.set('server', 'coin', '')
+    config.set('server', 'novacoin', '')
     config.set('server', 'datadir', '')
 
     # use leveldb as default
     config.set('server', 'backend', 'leveldb')
     config.add_section('leveldb')
-    config.set('leveldb', 'path', '/dev/shm/electrum_db')
+    config.set('leveldb', 'path_fulltree', '/dev/shm/electrum_db')
     config.set('leveldb', 'pruning_limit', '100')
 
     for path in ('/etc/', ''):
@@ -81,32 +82,14 @@ def create_config():
     return config
 
 
-def run_rpc_command(command, stratum_tcp_port):
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.connect((host, stratum_tcp_port))
-    except:
-        print "cannot connect to server."
-        return
+def run_rpc_command(params):
+    cmd = params[0]
+    import xmlrpclib
+    server = xmlrpclib.ServerProxy('http://localhost:7000')
+    func = getattr(server, cmd)
+    r = func(*params[1:])
 
-    method = 'server.' + command
-    params = [password]
-    if len(sys.argv) > 2:
-        params.append(sys.argv[2])
-    
-    request = json.dumps({'id': 0, 'method': method, 'params': params})
-    s.send(request + '\n')
-    msg = ''
-    while True:
-        o = s.recv(1024)
-        if not o: break
-        msg += o
-        if msg.find('\n') != -1:
-            break
-    s.close()
-    r = json.loads(msg).get('result')
-
-    if command == 'info':
+    if cmd == 'info':
         now = time.time()
         print 'type           address         sub  version  time'
         for item in r:
@@ -120,14 +103,40 @@ def run_rpc_command(command, stratum_tcp_port):
         print r
 
 
+def cmd_info():
+    return map(lambda s: {"time": s.time,
+                          "name": s.name,
+                          "address": s.address,
+                          "version": s.version,
+                          "subscriptions": len(s.subscriptions)},
+               dispatcher.request_dispatcher.get_sessions())
+
+def cmd_debug(s):
+    if s:
+        from guppy import hpy
+        h = hpy()
+        bp = dispatcher.request_dispatcher.processors['blockchain']
+        try:
+            result = str(eval(s))
+        except:
+            result = "error"
+        return result
+
+
+def get_port(config, name):
+    try:
+        return config.getint('server', name)
+    except:
+        return None
+
 if __name__ == '__main__':
     config = create_config()
     password = config.get('server', 'password')
     host = config.get('server', 'host')
-    stratum_tcp_port = config.getint('server', 'stratum_tcp_port')
-    stratum_http_port = config.getint('server', 'stratum_http_port')
-    stratum_tcp_ssl_port = config.getint('server', 'stratum_tcp_ssl_port')
-    stratum_http_ssl_port = config.getint('server', 'stratum_http_ssl_port')
+    stratum_tcp_port = get_port(config, 'stratum_tcp_port')
+    stratum_http_port = get_port(config, 'stratum_http_port')
+    stratum_tcp_ssl_port = get_port(config, 'stratum_tcp_ssl_port')
+    stratum_http_ssl_port = get_port(config, 'stratum_http_ssl_port')
     ssl_certfile = config.get('server', 'ssl_certfile')
     ssl_keyfile = config.get('server', 'ssl_keyfile')
 
@@ -135,15 +144,17 @@ if __name__ == '__main__':
         assert ssl_certfile and ssl_keyfile
 
     if len(sys.argv) > 1:
-        run_rpc_command(sys.argv[1], stratum_tcp_port)
+        try:
+            run_rpc_command(sys.argv[1:])
+        except socket.error:
+            print "server not running"
+            sys.exit(1)
         sys.exit(0)
 
     try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.connect((host, stratum_tcp_port))
-        s.close()
+        run_rpc_command(['getpid'])
         is_running = True
-    except:
+    except socket.error:
         is_running = False
 
     if is_running:
@@ -172,6 +183,15 @@ if __name__ == '__main__':
     dispatcher = Dispatcher(config)
     shared = dispatcher.shared
 
+    # handle termination signals
+    import signal
+    def handler(signum = None, frame = None):
+        print_log('Signal handler called with signal', signum)
+        shared.stop()
+    for sig in [signal.SIGTERM, signal.SIGHUP, signal.SIGQUIT]:
+        signal.signal(sig, handler)
+
+
     # Create and register processors
     chain_proc = BlockchainProcessor(config, shared)
     dispatcher.register('blockchain', chain_proc)
@@ -200,9 +220,21 @@ if __name__ == '__main__':
     for server in transports:
         server.start()
 
+    
+
+    from SimpleXMLRPCServer import SimpleXMLRPCServer
+    server = SimpleXMLRPCServer(('localhost',7000), allow_none=True, logRequests=False)
+    server.register_function(lambda: os.getpid(), 'getpid')
+    server.register_function(shared.stop, 'stop')
+    server.register_function(cmd_info, 'info')
+    server.register_function(cmd_debug, 'debug')
+    server.socket.settimeout(1)
+ 
     while not shared.stopped():
         try:
-            time.sleep(1)
+            server.handle_request()
+        except socket.timeout:
+            continue
         except:
             shared.stop()