remove support for native protocol

diff --git a/electrum.conf.sample b/electrum.conf.sample
index aa6956c..62c4477 100644 (file)
--- a/electrum.conf.sample
+++ b/electrum.conf.sample
@@ -1,6 +1,5 @@
 [server]
 host = localhost
-native_port = 
 stratum_tcp_port = 50001
 stratum_http_port = 8081
 password = secret

diff --git a/server.py b/server.py
index 8141273..914a6bb 100755 (executable)
--- a/server.py
+++ b/server.py
@@ -34,7 +34,6 @@ def create_config():
     config.add_section('server')
     config.set('server', 'banner', 'Welcome to Electrum!')
     config.set('server', 'host', 'localhost')
-    config.set('server', 'native_port', '50000')
     config.set('server', 'stratum_tcp_port', '50001')
     config.set('server', 'stratum_http_port', '8081')
     config.set('server', 'password', '')
@@ -80,7 +79,6 @@ if __name__ == '__main__':
     config = create_config()
     password = config.get('server', 'password')
     host = config.get('server', 'host')
-    native_port = config.get('server', 'native_port')
     stratum_tcp_port = config.get('server', 'stratum_tcp_port')
     stratum_http_port = config.get('server', 'stratum_http_port')
 
@@ -89,16 +87,9 @@ if __name__ == '__main__':
         sys.exit(0)
 
     from processor import Dispatcher
-    from transports.stratum_http import HttpServer
-    from transports.stratum_tcp import TcpServer
-    from transports.native import NativeServer
 
     from backends.irc import ServerProcessor
     backend_name = config.get('server', 'backend')
-    if backend_name == "libbitcoin":
-        # NativeServer cannot be used with libbitcoin
-        native_port = None
-        config.set('server', 'native_port', '')
     try:
         backend = __import__("backends." + backend_name,
                              fromlist=["BlockchainProcessor"])
@@ -119,17 +110,13 @@ if __name__ == '__main__':
 
     transports = []
     # Create various transports we need
-    if native_port:
-        server_banner = config.get('server','banner')
-        native_server = NativeServer(shared, chain_proc, server_proc,
-                                     server_banner, host, int(native_port))
-        transports.append(native_server)
-
     if stratum_tcp_port:
+        from transports.stratum_tcp import TcpServer
         tcp_server = TcpServer(dispatcher, host, int(stratum_tcp_port))
         transports.append(tcp_server)
 
     if stratum_http_port:
+        from transports.stratum_http import HttpServer
         http_server = HttpServer(dispatcher, host, int(stratum_http_port))
         transports.append(http_server)
 

diff --git a/transports/native.py b/transports/native.py
deleted file mode 100644 (file)
index 2cc4313..0000000
--- a/transports/native.py
+++ /dev/null
@@ -1,203 +0,0 @@
-import thread, threading, time, socket, traceback, ast, sys
-
-
-from processor import timestr, random_string
-
-
-
-def new_to_old(s):
-    s = s.replace("'block_hash'", "'blk_hash'")
-    s = s.replace("'index'", "'pos'")
-    s = s.replace("'timestamp'", "'nTime'")
-    s = s.replace("'is_input'", "'is_in'")
-    s = s.replace("'raw_output_script'","'raw_scriptPubKey'")
-    return s
-
-
-class NativeServer(threading.Thread):
-
-    def __init__(self, shared, abe, irc, banner, host, port):
-        threading.Thread.__init__(self)
-        self.banner = banner
-        self.abe = abe
-        self.store = abe.store
-        self.irc = irc
-        self.sessions = {}
-        self.host = host
-        self.port = port
-        self.daemon = True
-        self.shared = shared
-
-
-    def modified_addresses(self,a_session):
-        import copy
-        session = copy.deepcopy(a_session)
-        addresses = session['addresses']
-        session['last_time'] = time.time()
-        ret = {}
-        k = 0
-        for addr in addresses.keys():
-            status = self.store.get_status( addr )
-            msg_id, last_status = addresses[addr]
-            if last_status != status:
-                addresses[addr] = msg_id, status
-                ret[addr] = status
-
-        return ret, addresses
-
-
-    def poll_session(self, session_id): 
-        session = self.sessions.get(session_id)
-        if session is None:
-            print time.asctime(), "session not found", session_id
-            return -1, {}
-        else:
-            self.sessions[session_id]['last_time'] = time.time()
-            ret, addresses = self.modified_addresses(session)
-            if ret: self.sessions[session_id]['addresses'] = addresses
-            return repr( (self.abe.block_number,ret))
-
-
-    def add_address_to_session(self, session_id, address):
-        status = self.store.get_status(address)
-        self.sessions[session_id]['addresses'][address] = ("", status)
-        self.sessions[session_id]['last_time'] = time.time()
-        return status
-
-
-    def new_session(self, version, addresses):
-        session_id = random_string(10)
-        self.sessions[session_id] = { 'addresses':{}, 'version':version }
-        for a in addresses:
-            self.sessions[session_id]['addresses'][a] = ('','')
-        out = repr( (session_id, self.banner.replace('\\n','\n') ) )
-        self.sessions[session_id]['last_time'] = time.time()
-        return out
-
-
-    def update_session(self, session_id,addresses):
-        """deprecated in 0.42, wad replaced by add_address_to_session"""
-        self.sessions[session_id]['addresses'] = {}
-        for a in addresses:
-            self.sessions[session_id]['addresses'][a] = ('','')
-        self.sessions[session_id]['last_time'] = time.time()
-        return 'ok'
-
-
-
-    def native_client_thread(self, ipaddr,conn):
-        try:
-            ipaddr = ipaddr[0]
-            msg = ''
-            while 1:
-                d = conn.recv(1024)
-                msg += d
-                if not d: 
-                    break
-                if '#' in msg:
-                    msg = msg.split('#', 1)[0]
-                    break
-            try:
-                cmd, data = ast.literal_eval(msg)
-            except:
-                print "syntax error", repr(msg), ipaddr
-                conn.close()
-                return
-
-            out = self.do_command(cmd, data, ipaddr)
-            if out:
-                #print ipaddr, cmd, len(out)
-                try:
-                    conn.send(out)
-                except:
-                    print "error, could not send"
-
-        finally:
-            conn.close()
-
-
-
-    def do_command(self, cmd, data, ipaddr):
-
-        if cmd=='b':
-            out = "%d"%self.abe.block_number
-
-        elif cmd in ['session','new_session']:
-            try:
-                if cmd == 'session':
-                    addresses = ast.literal_eval(data)
-                    version = "old"
-                else:
-                    version, addresses = ast.literal_eval(data)
-                    if version[0]=="0": version = "v" + version
-            except:
-                print "error", data
-                return None
-            print timestr(), "new session", ipaddr, addresses[0] if addresses else addresses, len(addresses), version
-            out = self.new_session(version, addresses)
-
-        elif cmd=='address.subscribe':
-            try:
-                session_id, addr = ast.literal_eval(data)
-            except:
-                traceback.print_exc(file=sys.stdout)
-                print data
-                return None
-            out = self.add_address_to_session(session_id,addr)
-
-        elif cmd=='update_session':
-            try:
-                session_id, addresses = ast.literal_eval(data)
-            except:
-                traceback.print_exc(file=sys.stdout)
-                return None
-            print timestr(), "update session", ipaddr, addresses[0] if addresses else addresses, len(addresses)
-            out = self.update_session(session_id,addresses)
-            
-        elif cmd=='poll': 
-            out = self.poll_session(data)
-
-        elif cmd == 'h': 
-            address = data
-            out = repr( self.store.get_history( address ) )
-            out = new_to_old(out)
-
-        elif cmd =='tx':
-            out = self.store.send_tx(data)
-            print timestr(), "sent tx:", ipaddr, out
-
-        elif cmd == 'peers':
-            out = repr(self.irc.get_peers())
-
-        else:
-            out = None
-
-        return out
-
-
-    def clean_session_thread(self):
-        while not self.shared.stopped():
-            time.sleep(30)
-            t = time.time()
-            for k,s in self.sessions.items():
-                if s.get('type') == 'persistent': continue
-                t0 = s['last_time']
-                if t - t0 > 5*60:
-                    self.sessions.pop(k)
-                    print "lost session", k
-            
-    def run(self):
-        thread.start_new_thread(self.clean_session_thread, ())
-
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        s.bind((self.host, self.port)) 
-        s.listen(1)
-        while not self.shared.stopped():
-            conn, addr = s.accept()
-            try:
-                thread.start_new_thread(self.native_client_thread, (addr, conn,))
-            except:
-                # can't start new thread if there is no memory..
-                traceback.print_exc(file=sys.stdout)
-