server_twisted.py

   1 #!/usr/bin/python
   2
   3 # This is a twisted version of the server
   4
   5 import os, sys
   6 from os.path import exists
   7
   8 import signal
   9 from signal import *
  10
  11 from xml.dom.minidom import parse, parseString
  12
  13 from twisted.internet.protocol import DatagramProtocol
  14 from twisted.internet import reactor
  15 from twisted.internet import task
  16
  17 CONFIG = 'config.xml'
  18
  19 BROADCAST = 50030
  20 MESSAGE = 40031
  21 PASSWORD = "changethis"
  22 NAME = "default"
  23
  24 ECHO_TIME = 1
  25
  26 ECHO_COUNT = 5 # this is the number of times one can ignore an echo until the server drops you
  27
  28 running = 1
  29
  30 from protocol import *
  31
  32 MULTICAST = '234.0.0.1'
  33
  34 def main():
  35
  36     # parsing command line options
  37
  38     if (len(sys.argv) > 1):
  39         config_file = sys.argv[1]
  40     else:
  41         print "main(): No config file specified, using", CONFIG
  42         config_file = CONFIG
  43
  44     global parsed_config
  45     parsed_config = parse_config(config_file)
  46
  47     if (parsed_config['error']):
  48         print "main(): Error parsing config, ending"
  49         return
  50
  51     signal(SIGINT, handler)
  52
  53     run(parsed_config)
  54
  55 def run(configuration):
  56
  57     global running
  58
  59     if running:
  60         print "run(): Beginning..."
  61
  62     global the_messenger
  63     global the_broadcast
  64
  65     global members
  66     members = {}
  67
  68     global ECHO_COUNT
  69
  70     if configuration.has_key('echo_number'):
  71         ECHO_COUNT = configuration['echo_number']
  72     else:
  73         print "No echo_number specified in config file, using default of", ECHO_COUNT
  74
  75     the_broadcast = Broadcast()
  76     the_messenger = Messenger()
  77
  78     the_messenger.echo_members = []
  79
  80     if configuration.has_key('broadcast'):
  81         reactor.listenMulticast(configuration['broadcast'], the_broadcast)
  82     else:
  83         print "Server.__init__(): No broadcast socket number chosen, using", BROADCAST
  84         reactor.listenMulticast(BROADCAST, the_broadcast)
  85
  86     if configuration.has_key('message'):
  87         reactor.listenUDP(configuration['message'], the_messenger)
  88     else:
  89         print "Server.__init__(): No message socket number chosen, using", MESSAGE
  90         reactor.listenUDP(MESSAGE, the_messenger)
  91
  92     echo_request = task.LoopingCall(the_messenger.echo_request)
  93
  94     if configuration.has_key('echo_time'):
  95         echo_request.start(configuration['echo_time'])
  96     else:
  97         print "run(): No echo_time specified in config, using default of", ECHO_TIME
  98         echo_request.start(ECHO_TIME)
  99
 100     reactor.run()
 101
 102     print "run(): Ending..."
 103
 104     return
 105
 106 def handler(signal, frame):
 107
 108     global running
 109     running = 0
 110
 111     reactor.stop()
 112
 113     return
 114
 115 def is_end():
 116
 117     if not running:
 118         reactor.stop()
 119
 120     return
 121
 122 def parse_config(filename):
 123
 124     parsed = {'error': 1}
 125
 126     if (exists(filename)):
 127         dom = parse(filename)
 128     else:
 129         print "parse_config():", filename, "doesn't exist"
 130         return parsed
 131
 132     if (dom.childNodes[0].nodeName == 'server_config'):
 133         for node in dom.childNodes[0].childNodes:
 134
 135             if (node.nodeName == 'name' and len(node.childNodes)):
 136                 parsed['name'] = node.childNodes[0].nodeValue
 137
 138             if (node.nodeName == 'password' and len(node.childNodes)):
 139                 parsed['password'] = node.childNodes[0].nodeValue
 140
 141             if (node.nodeName == 'broadcast' and len(node.childNodes)):
 142                 parsed['broadcast'] = int(node.childNodes[0].nodeValue)
 143
 144             if (node.nodeName == 'message' and len(node.childNodes)):
 145                 parsed['message'] = int(node.childNodes[0].nodeValue)
 146
 147             if (node.nodeName == 'echo_time' and len(node.childNodes)):
 148                 parsed['echo_time'] = int(node.childNodes[0].nodeValue)
 149
 150             if (node.nodeName == 'echo_number' and len(node.childNodes)):
 151                 parsed['echo_number'] = int(node.childNodes[0].nodeValue)
 152
 153     parsed['error'] = 0
 154
 155     return parsed
 156
 157 class Broadcast(DatagramProtocol):
 158
 159     def startProtocol(self):
 160
 161         self.transport.joinGroup(MULTICAST)
 162
 163     def datagramReceived(self, data, address):
 164
 165         global parsed_config
 166
 167         if data[0:len(SERVERREQUEST)] == SERVERREQUEST:
 168
 169             new_message = ''.join([SERVEROFFER, " ",
 170                                    str(parsed_config['message']),
 171                                    " ", parsed_config['name']])
 172
 173             destination = (address[0], int(data[len(SERVERREQUEST) + 1:]))
 174
 175             the_messenger.transport.write(new_message, destination)
 176
 177             print "Broadcast.datagramReceived(): Received SERVERREQUEST, responded with SERVEROFFER"
 178
 179         return
 180
 181 class Messenger(DatagramProtocol):
 182
 183     def datagramReceived(self, data, (host, port)):
 184
 185         global members
 186         global parsed_config
 187
 188         if data[:len(WANTIN)] == WANTIN:
 189
 190             if not members.has_key(data[len(WANTIN) + 1:]):
 191                 print "Messenger.datagramReceived(): WANTIN received, responding with YOUREIN"
 192
 193                 response = ''.join([SOMEONEJOINED, " ", data[len(WANTIN) + 1:]])
 194
 195                 for member in members:
 196                     self.transport.write(response, members[member])
 197
 198                 members[data[len(WANTIN) + 1:]] = (host, port)
 199                 response = YOUREIN
 200                 self.transport.write(response, (host, port))
 201
 202             else:
 203                 if (host, port) in members.values():
 204                  print "Messenger.datagramReceived(): WANTIN received from a current member, responding with YOUREIN"
 205                  response = YOUREIN
 206                  self.transport.write(response, (host, port))
 207
 208                 else:
 209                   response = NAMEDENIED
 210                   self.transport.write(response, (host, port))
 211
 212         if data[:len(IMHERE)] == IMHERE:
 213
 214             if (host, port) in members.values():
 215
 216                 # print "Messenger.datagramReceived(): IMHERE received"
 217
 218                 for name in members:
 219                     if members[name] == (host, port):
 220                         if name in self.echo_members:
 221                             while self.echo_members.count(name):
 222                                 self.echo_members.remove(name)
 223
 224         if data[:len(YOUTHERE)] == YOUTHERE:
 225
 226             #print "Messenger.datagramReceived(): YOUTHERE received, responding with IMHERE"
 227
 228             self.transport.write(IMHERE, (host, port))
 229
 230         if data[:len(IMOUT)] == IMOUT:
 231
 232             if (host, port) in members.values():
 233                 print "Messenger.datagramReceived(): IMOUT received, notifying others"
 234
 235                 response = ''.join([SOMEONELEFT, " "])
 236
 237                 the_name = ''
 238                 for name in members.keys():
 239                     if members[name] == (host, port):
 240                         the_name = name
 241
 242                 self.ejectMember(the_name)
 243
 244             else:
 245                 print "Messenger.datagramReceived(): IMOUT received, but sender not present in listing"
 246
 247         if data[:len(GETLIST)] == GETLIST:
 248             print "Messenger.datagramReceived(): GETLIST received, responding with LIST"
 249
 250             response = ''.join([LIST, ' '])
 251
 252             for iname in members:
 253                 response = ''.join([response, iname, ' '])
 254
 255             self.transport.write(response, (host, port))
 256
 257         if data[:len(SERVERKILL)] == SERVERKILL:
 258
 259             if data[len(SERVERKILL) + 1:] == parsed_config['password']:
 260                 print "Messenger.datagramReceived(): SERVERKILL received, dying now."
 261                 reactor.stop()
 262
 263         if data[:len(LETTER)] == LETTER:
 264
 265             responses = []
 266
 267             origin = ''
 268
 269             for name in members:
 270                 if members[name] == (host, port):
 271                     origin = name
 272
 273             if origin == '':
 274                 print "Messenger.datagramReceived(): LETTER received, but originator not in listing"
 275             else:
 276                 print "Messenger.datagramReceived(): LETTER received, forwarding it on..."
 277
 278                 response = [''.join([LETTER, ':', origin, ':']), []]
 279                 message = ''
 280
 281                 if data[len(LETTER):len(LETTER) + 2] == '::':
 282
 283                     message = data[data.find("::") + 2:]
 284                     response[0] = ''.join([response[0], message])
 285
 286                     for name in members:
 287                         if origin != name:
 288
 289                             responses.append(response)
 290                             responses[-1][1] = members[name]
 291                 else:
 292
 293                     message = data[the_data.find(':', data.find(':') + 1) + 1:]
 294                     response[0] = ''.join([response[0], messsage])
 295
 296                     string_parts = data[data.find(':') + 1:
 297                                         data.find(':', data.find(':') + 1)].split()
 298
 299                     for dest in string_parts:
 300
 301                         if members.has_key(dest):
 302
 303                             responses.append(response)
 304                             responses[-1][1] = members[dest]
 305
 306                 for response_i in responses:
 307
 308                     self.transport.write(response_i[0], response_i[1])
 309
 310         return
 311
 312     def ejectMember(self, name):
 313
 314         reactor.callFromThread(self.ejectThreadMember, name)
 315
 316         return
 317
 318     def ejectThreadMember(self, name):
 319         if name in members.keys():
 320             response = YOUROUT
 321             self.transport.write(response, members[name])
 322
 323             del members[name]
 324
 325             response = ''.join([SOMEONELEFT, " ", name])
 326
 327             for member in members:
 328
 329                 self.transport.write(response, members[member])
 330                 print "notify debug", members[member], response
 331
 332         return
 333
 334     def echo_request(self):
 335
 336         global members
 337         global parsed_config
 338         global ECHO_COUNT
 339
 340         ejecters = []
 341
 342         if len(members):
 343             #print "Messenger.echo_request(): Sending YOUTHERE messages..."
 344             pass
 345
 346         for member in members:
 347
 348             if self.echo_members.count(member) > ECHO_COUNT:
 349                 ejecters.append(member)
 350
 351             else:
 352                 self.transport.write(STILLIN, members[member])
 353                 self.echo_members.append(member)
 354
 355         for person in ejecters:
 356
 357             self.ejectMember(person)
 358             print "Messenger.echo_request(): Member ejected for suspicion of communism, name:", person
 359
 360             temp_members = []
 361
 362             for echo_request_item in self.echo_members:
 363                 if person != echo_request_item:
 364                     temp_members.append(echo_request_item)
 365
 366             self.echo_members = temp_members
 367
 368         return
 369
 370 if __name__ == '__main__':
 371     main()