backends/irc/__init__.py

   1 import threading, socket, traceback, time, sys
   2
   3 def random_string(N):
   4     import random, string
   5     return ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(N))
   6
   7 from processor import Processor
   8 from version import VERSION
   9
  10 class IrcThread(threading.Thread):
  11
  12     def __init__(self, processor, config):
  13         threading.Thread.__init__(self)
  14         self.processor = processor
  15         self.daemon = True
  16         self.stratum_tcp_port = config.get('server','stratum_tcp_port')
  17         self.stratum_http_port = config.get('server','stratum_http_port')
  18         self.stratum_tcp_ssl_port = config.get('server','stratum_tcp_ssl_port')
  19         self.stratum_http_ssl_port = config.get('server','stratum_http_ssl_port')
  20         self.peers = {}
  21         self.host = config.get('server','host')
  22         self.nick = config.get('server', 'irc_nick')
  23         if not self.nick: self.nick = random_string(10)
  24         self.prepend = 'E_'
  25         if config.get('server', 'coin') == 'litecoin':
  26             self.prepend = 'EL_'
  27         self.nick = self.prepend + self.nick
  28
  29     def get_peers(self):
  30         return self.peers.values()
  31
  32
  33     def getname(self):
  34         s = 'v' + VERSION + ' '
  35         if self.stratum_tcp_port:
  36             s += 't' + self.stratum_tcp_port + ' '
  37         if self.stratum_http_port:
  38             s += 'h' + self.stratum_http_port + ' '
  39         if self.stratum_tcp_port:
  40             s += 's' + self.stratum_tcp_ssl_port + ' '
  41         if self.stratum_http_port:
  42             s += 'g' + self.stratum_http_ssl_port + ' '
  43         return s
  44
  45
  46     def run(self):
  47         ircname = self.getname()
  48
  49         while not self.processor.shared.stopped():
  50             try:
  51                 s = socket.socket()
  52                 s.connect(('irc.freenode.net', 6667))
  53             except:
  54                 time.sleep(10)
  55                 continue
  56
  57             try:
  58                 s.send('USER electrum 0 * :' + self.host + ' ' + ircname + '\n')
  59                 s.send('NICK ' + self.nick + '\n')
  60                 s.send('JOIN #electrum\n')
  61                 sf = s.makefile('r', 0)
  62                 t = 0
  63                 while not self.processor.shared.stopped():
  64                     line = sf.readline()
  65                     line = line.rstrip('\r\n')
  66                     line = line.split()
  67                     if not line: continue
  68                     if line[0]=='PING':
  69                         s.send('PONG '+line[1]+'\n')
  70                     elif '353' in line: # answer to /names
  71                         k = line.index('353')
  72                         for item in line[k+1:]:
  73                             if item.startswith(self.prepend):
  74                                 s.send('WHO %s\n'%item)
  75                     elif '352' in line: # answer to /who
  76                         # warning: this is a horrible hack which apparently works
  77                         k = line.index('352')
  78                         ip = line[k+4]
  79                         ip = socket.gethostbyname(ip)
  80                         name = line[k+6]
  81                         host = line[k+9]
  82                         ports  = line[k+10:]
  83                         self.peers[name] = (ip, host, ports)
  84                     if time.time() - t > 5*60:
  85                         self.processor.push_response({'method':'server.peers', 'params':[self.get_peers()]})
  86                         s.send('NAMES #electrum\n')
  87                         t = time.time()
  88                         self.peers = {}
  89             except:
  90                 traceback.print_exc(file=sys.stdout)
  91             finally:
  92                 sf.close()
  93                 s.close()
  94
  95         print "quitting IRC"
  96
  97
  98
  99 class ServerProcessor(Processor):
 100
 101     def __init__(self, config):
 102         Processor.__init__(self)
 103         self.daemon = True
 104         self.banner = config.get('server','banner')
 105         self.password = config.get('server','password')
 106
 107         if config.get('server', 'irc') == 'yes':
 108             self.irc = IrcThread(self, config)
 109         else:
 110             self.irc = None
 111
 112
 113     def get_peers(self):
 114         if self.irc:
 115             return self.irc.get_peers()
 116         else:
 117             return []
 118
 119
 120     def run(self):
 121         if self.irc:
 122             self.irc.start()
 123         Processor.run(self)
 124
 125     def process(self, request):
 126         method = request['method']
 127         params = request['params']
 128         result = None
 129
 130         if method in ['server.stop', 'server.info']:
 131             try:
 132                 password = request['params'][0]
 133             except:
 134                 password = None
 135
 136             if password != self.password:
 137                 response = { 'id':request['id'], 'result':None,  'error':'incorrect password'}
 138                 self.push_response(response)
 139                 return
 140
 141         if method == 'server.banner':
 142             result = self.banner.replace('\\n','\n')
 143
 144         elif method == 'server.peers.subscribe':
 145             result = self.get_peers()
 146
 147         elif method == 'server.version':
 148             result = VERSION
 149
 150         elif method == 'server.stop':
 151             self.shared.stop()
 152             result = 'stopping, please wait until all threads terminate.'
 153
 154         elif method == 'server.info':
 155             result = map(lambda s: { "time":s.time,
 156                                      "name":s.name,
 157                                      "address":s.address,
 158                                      "version":s.version,
 159                                      "subscriptions":len(s.subscriptions)},
 160                          self.dispatcher.request_dispatcher.get_sessions())
 161
 162         elif method == 'server.cache':
 163             p = self.dispatcher.request_dispatcher.processors['blockchain']
 164             result = len(repr(p.store.tx_cache))
 165
 166         elif method == 'server.load':
 167             p = self.dispatcher.request_dispatcher.processors['blockchain']
 168             result = p.queue.qsize()
 169
 170         else:
 171             print "unknown method", request
 172
 173         if result!='':
 174             response = { 'id':request['id'], 'result':result }
 175             self.push_response(response)
 176