import ConfigParser
from json import dumps, loads
import urllib
-
+import threading
config = ConfigParser.ConfigParser()
# set some defaults, which will be overwritten by the config file
password = config.get('server','password')
stopping = False
-block_number = -1
sessions = {}
-sessions_sub_numblocks = {} # sessions that have subscribed to the service
m_sessions = [{}] # served by http
-peer_list = {}
from Queue import Queue
input_queue = Queue()
sessions[session_id]['last_time'] = time.time()
ret, addresses = modified_addresses(session)
if ret: sessions[session_id]['addresses'] = addresses
- return repr( (block_number,ret))
+ return repr( (store.block_number,ret))
def poll_session_json(session_id, message_id):
return out
-def do_update_address(addr):
- # an address was involved in a transaction; we check if it was subscribed to in a session
- # the address can be subscribed in several sessions; the cache should ensure that we don't do redundant requests
-
- for session_id in sessions.keys():
- session = sessions[session_id]
- if session.get('type') != 'persistent': continue
- addresses = session['addresses'].keys()
-
- if addr in addresses:
- status = store.get_status( addr )
- message_id, last_status = session['addresses'][addr]
- if last_status != status:
- #print "sending new status for %s:"%addr, status
- send_status(session_id,message_id,addr,status)
- sessions[session_id]['addresses'][addr] = (message_id,status)
-
-
-def send_numblocks(session_id):
- message_id = sessions_sub_numblocks[session_id]
- out = json.dumps( {'id':message_id, 'result':block_number} )
- output_queue.put((session_id, out))
-
-def send_status(session_id, message_id, address, status):
- out = json.dumps( { 'id':message_id, 'result':status } )
- output_queue.put((session_id, out))
def address_get_history_json(_,message_id,address):
return store.get_history(address)
-def subscribe_to_numblocks(session_id, message_id):
- sessions_sub_numblocks[session_id] = message_id
- send_numblocks(session_id)
-
def subscribe_to_numblocks_json(session_id, message_id):
global m_sessions
m_sessions[0][session_id]['numblocks'] = message_id,block_number
return block_number
-def subscribe_to_address(session_id, message_id, address):
- status = store.get_status(address)
- sessions[session_id]['addresses'][address] = (message_id, status)
- sessions[session_id]['last_time'] = time.time()
- send_status(session_id, message_id, address, status)
-
def add_address_to_session_json(session_id, message_id, address):
global m_sessions
sessions = m_sessions[0]
sessions[session_id]['version'] = version
m_sessions[0] = sessions
-def create_session_json(_, __):
- sessions = m_sessions[0]
- session_id = random_string(10)
- print "creating session", session_id
- sessions[session_id] = { 'addresses':{}, 'numblocks':('','') }
- sessions[session_id]['last_time'] = time.time()
- m_sessions[0] = sessions
- return session_id
-
def get_banner(_,__):
return config.get('server','banner').replace('\\n','\n')
def update_session(session_id,addresses):
- """deprecated in 0.42"""
+ """deprecated in 0.42, wad replaced by add_address_to_session"""
sessions[session_id]['addresses'] = {}
for a in addresses:
sessions[session_id]['addresses'][a] = ''
out = cmd_stop(data)
elif cmd == 'peers':
- out = repr(peer_list.values())
+ out = repr(irc.get_peers())
else:
out = None
import stratum
class AbeProcessor(stratum.Processor):
- def process(self,session,request):
+ def process(self,request):
message_id = request['id']
method = request['method']
params = request.get('params',[])
+ #print request
result = ''
if method == 'numblocks.subscribe':
- session.subscribe_to_numblocks(message_id)
- result = block_number
+ result = store.block_number
elif method == 'address.subscribe':
address = params[0]
+ store.watch_address(address)
status = store.get_status(address)
- session.subscribe_to_address(address,message_id,status)
result = status
elif method == 'client.version':
- session.version = params[0]
+ #session.version = params[0]
+ pass
elif method == 'server.banner':
result = config.get('server','banner').replace('\\n','\n')
elif method == 'server.peers':
- result = peer_list.values()
+ result = irc.get_peers()
elif method == 'address.get_history':
address = params[0]
result = store.get_history( address )
print "unknown method", request
if result!='':
- response = { 'id':message_id, 'result':result }
- self.push_response(session,response)
+ response = { 'id':message_id, 'method':method, 'params':params, 'result':result }
+ self.push_response(response)
+
+ def get_status(self,addr):
+ return store.get_status(addr)
+class Irc(threading.Thread):
+ def __init__(self, processor):
+ self.processor = processor
+ threading.Thread.__init__(self)
+ self.daemon = True
+ self.peers = {}
-def irc_thread():
- global peer_list
- NICK = 'E_'+random_string(10)
- while not stopping:
- try:
- s = socket.socket()
- s.connect(('irc.freenode.net', 6667))
- s.send('USER electrum 0 * :'+config.get('server','host')+' '+config.get('server','ircname')+'\n')
- s.send('NICK '+NICK+'\n')
- s.send('JOIN #electrum\n')
- sf = s.makefile('r', 0)
- t = 0
- while not stopping:
- line = sf.readline()
- line = line.rstrip('\r\n')
- line = line.split()
- if line[0]=='PING':
- s.send('PONG '+line[1]+'\n')
- elif '353' in line: # answer to /names
- k = line.index('353')
- for item in line[k+1:]:
- if item[0:2] == 'E_':
- s.send('WHO %s\n'%item)
- elif '352' in line: # answer to /who
- # warning: this is a horrible hack which apparently works
- k = line.index('352')
- ip = line[k+4]
- ip = socket.gethostbyname(ip)
- name = line[k+6]
- host = line[k+9]
- peer_list[name] = (ip,host)
- if time.time() - t > 5*60:
- s.send('NAMES #electrum\n')
- t = time.time()
- peer_list = {}
- except:
- traceback.print_exc(file=sys.stdout)
- finally:
- sf.close()
- s.close()
+ def get_peers(self):
+ return self.peers.values()
+
+ def run(self):
+ NICK = 'E_'+random_string(10)
+ while not self.processor.shared.stopped():
+ try:
+ s = socket.socket()
+ s.connect(('irc.freenode.net', 6667))
+ s.send('USER electrum 0 * :'+config.get('server','host')+' '+config.get('server','ircname')+'\n')
+ s.send('NICK '+NICK+'\n')
+ s.send('JOIN #electrum\n')
+ sf = s.makefile('r', 0)
+ t = 0
+ while not self.processor.shared.stopped():
+ line = sf.readline()
+ line = line.rstrip('\r\n')
+ line = line.split()
+ if line[0]=='PING':
+ s.send('PONG '+line[1]+'\n')
+ elif '353' in line: # answer to /names
+ k = line.index('353')
+ for item in line[k+1:]:
+ if item[0:2] == 'E_':
+ s.send('WHO %s\n'%item)
+ elif '352' in line: # answer to /who
+ # warning: this is a horrible hack which apparently works
+ k = line.index('352')
+ ip = line[k+4]
+ ip = socket.gethostbyname(ip)
+ name = line[k+6]
+ host = line[k+9]
+ self.peers[name] = (ip,host)
+ if time.time() - t > 5*60:
+ self.processor.push_response({'method':'server.peers', 'result':[self.get_peers()]})
+ s.send('NAMES #electrum\n')
+ t = time.time()
+ self.peers = {}
+ except:
+ traceback.print_exc(file=sys.stdout)
+ finally:
+ sf.close()
+ s.close()
def get_peers_json(_,__):
- return peer_list.values()
+ return irc.get_peers()
def http_server_thread():
# see http://code.google.com/p/jsonrpclib/
# supported protocols
thread.start_new_thread(native_server_thread, ())
-
- thread.start_new_thread(http_server_thread, ())
thread.start_new_thread(clean_session_thread, ())
- #tcp stratum
- stratum_processor = AbeProcessor()
+ #thread.start_new_thread(http_server_thread, ())
+
+
+ processor = AbeProcessor()
shared = stratum.Shared()
# Bind shared to processor since constructor is user defined
- stratum_processor.shared = shared
- stratum_processor.start()
+ processor.shared = shared
+ processor.start()
+
# Create various transports we need
- server = stratum.TcpServer(shared, stratum_processor, "ecdsa.org",50001)
- server.start()
- if (config.get('server','irc') == 'yes' ):
- thread.start_new_thread(irc_thread, ())
+ #tcp stratum
+ tcpserver = stratum.TcpServer(shared, processor, "ecdsa.org",50001)
+ tcpserver.start()
- print "starting Electrum server"
+ #http stratum
+ from stratum_http import HttpServer
+ server = HttpServer(shared, processor, "ecdsa.org",8081)
+ server.start()
- old_block_number = None
- while not stopping:
- block_number = store.main_iteration()
- if block_number != old_block_number:
- old_block_number = block_number
- for session_id in sessions_sub_numblocks.keys():
- send_numblocks(session_id)
+ if (config.get('server','irc') == 'yes' ):
+ irc = Irc(processor)
+ irc.start()
- for session in stratum_processor.sessions:
- if session.numblocks_sub is not None:
- response = { 'id':session.numblocks_sub, 'result':block_number }
- stratum_processor.push_response(session,response)
- while True:
- try:
- addr = store.address_queue.get(False)
- except:
- break
- do_update_address(addr)
-
- for session in stratum_processor.sessions:
- m = session.addresses_sub.get(addr)
- if m:
- status = store.get_status( addr )
- message_id, last_status = m
- if status != last_status:
- session.subscribe_to_address(message_id, status)
- response = { 'id':message_id, 'result':status }
- stratum_processor.push_response(session,response)
-
- time.sleep(10)
+ print "starting Electrum server"
+ store.run(processor)
print "server stopped"