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
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] = ''
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':
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)
# 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)
+
+ #tcp stratum
+ tcpserver = stratum.TcpServer(shared, processor, "ecdsa.org",50001)
+ tcpserver.start()
+
+ #http stratum
+ from StratumJSONRPCServer import HttpServer
+ server = HttpServer(shared, processor, "ecdsa.org",8081)
server.start()
+
if (config.get('server','irc') == 'yes' ):
thread.start_new_thread(irc_thread, ())
print "starting Electrum server"
-
- 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)
-
- 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)
+ store.run(processor)
print "server stopped"
git://git.novaco.in / electrum-server.git / blobdiff