.svn/text-base/server_twisted.py.svn-base

   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 = 5
  25
  26 running = 1
  27
  28 # defining protocol stuff
  29
  30 SERVERREQUEST = "i_want_server"
  31 SERVEROFFER = "Want_server?"
  32 SERVERKILL = "DIE_server!!"
  33 YOUTHERE = "you_there?"
  34 IMHERE = "yeah,i'm_here"
  35 WANTIN = "i_want_in"
  36 YOUREIN = "urine"
  37 IMOUT = "i_leave"
  38 GETLIST = "get_list"
  39 LIST = "peoples_on_server"
  40 SOMEONEJOINED = "dude,someone_joined"
  41 SOMEONELEFT = "someone_left"
  42 YOUROUT = "get_lost_punk"
  43 LETTER = "listen_to_me"
  44
  45 # end protocol stuff
  46
  47 MULTICAST = '234.0.0.1'
  48
  49 def main():
  50
  51     # parsing command line options
  52
  53     if (len(sys.argv) > 1):
  54         config_file = sys.argv[1]
  55     else:
  56         print "main(): No config file specified, using", CONFIG
  57         config_file = CONFIG
  58
  59     global parsed_config
  60     parsed_config = parse_config(config_file)
  61
  62     if (parsed_config['error']):
  63         print "main(): Error parsing config, ending"
  64         return
  65
  66     signal(SIGINT, handler)
  67
  68     run(parsed_config)
  69
  70 def run(configuration):
  71
  72     global running
  73
  74     if running:
  75         print "run(): Beginning..."
  76
  77     global the_messenger
  78     global the_broadcast
  79
  80     global members
  81     members = {}
  82
  83     the_broadcast = Broadcast()
  84     the_messenger = Messenger()
  85
  86     the_messenger.echo_members = []
  87
  88     if configuration.has_key('broadcast'):
  89         reactor.listenMulticast(configuration['broadcast'], the_broadcast)
  90     else:
  91         print "Server.__init__(): No broadcast socket number chosen, using", BROADCAST
  92         reactor.listenMulticast(BROADCAST, the_broadcast)
  93
  94     if configuration.has_key('message'):
  95         reactor.listenUDP(configuration['message'], the_messenger)
  96     else:
  97         print "Server.__init__(): No message socket number chosen, using", MESSAGE
  98         reactor.listenUDP(MESSAGE, the_messenger)
  99
 100     echo_request = task.LoopingCall(the_messenger.echo_request)
 101
 102     if configuration.has_key('echo_time'):
 103         echo_request.start(configuration['echo_time'])
 104     else:
 105         print "run(): No echo_time specified in config, using default of", ECHO_TIME
 106         echo_request.start(ECHO_TIME)
 107
 108     reactor.run()
 109
 110     print "run(): Ending..."
 111
 112     return
 113
 114 def handler(signal, frame):
 115
 116     global running
 117     running = 0
 118
 119     reactor.stop()
 120
 121     return
 122
 123 def is_end():
 124
 125     if not running:
 126         reactor.stop()
 127
 128     return
 129
 130 def parse_config(filename):
 131
 132     parsed = {'error': 1}
 133
 134     if (exists(filename)):
 135         dom = parse(filename)
 136     else:
 137         print "parse_config():", filename, "doesn't exist"
 138         return parsed
 139
 140     if (dom.childNodes[0].nodeName == 'server_config'):
 141         for node in dom.childNodes[0].childNodes:
 142
 143             if (node.nodeName == 'name' and len(node.childNodes)):
 144                 parsed['name'] = node.childNodes[0].nodeValue
 145
 146             if (node.nodeName == 'password' and len(node.childNodes)):
 147                 parsed['password'] = node.childNodes[0].nodeValue
 148
 149             if (node.nodeName == 'broadcast' and len(node.childNodes)):
 150                 parsed['broadcast'] = int(node.childNodes[0].nodeValue)
 151
 152             if (node.nodeName == 'message' and len(node.childNodes)):
 153                 parsed['message'] = int(node.childNodes[0].nodeValue)
 154
 155             if (node.nodeName == 'echo_time' and len(node.childNodes)):
 156                 parsed['echo_time'] = int(node.childNodes[0].nodeValue)
 157
 158     parsed['error'] = 0
 159
 160     return parsed
 161
 162 class Broadcast(DatagramProtocol):
 163
 164     def startProtocol(self):
 165
 166         self.transport.joinGroup(MULTICAST)
 167
 168     def datagramReceived(self, data, address):
 169
 170         global parsed_config
 171
 172         if data[0:len(SERVERREQUEST)] == SERVERREQUEST:
 173
 174             new_message = ''.join([SERVEROFFER, " ",
 175                                    str(parsed_config['message']),
 176                                    " ", parsed_config['name']])
 177
 178             destination = (address[0], int(data[len(SERVERREQUEST) + 1:]))
 179
 180             the_messenger.transport.write(new_message, destination)
 181
 182             print "Broadcast.datagramReceived(): Received SERVERREQUEST, responded with SERVEROFFER"
 183
 184         return
 185
 186 class Messenger(DatagramProtocol):
 187
 188     def datagramReceived(self, data, (host, port)):
 189
 190         global members
 191         global parsed_config
 192
 193         if data[:len(WANTIN)] == WANTIN:
 194
 195             print "Messenger.datagramReceived(): WANTIN received, responding with YOUREIN"
 196
 197             members[data[len(WANTIN) + 1:]] = (host, port)
 198             response = YOUREIN
 199             self.transport.write(response, (host, port))
 200
 201         if data[:len(YOUTHERE)] == YOUTHERE:
 202
 203             print "Messenger.datagramReceived(): YOUTHERE received, responding with IMHERE"
 204
 205             self.transport.write(IMHERE, (host, port))
 206
 207         if data[:len(IMOUT)] == IMOUT:
 208
 209             if (host, port) in members.values():
 210                 print "Messenger.datagramReceived(): IMOUT received, notifying others"
 211
 212                 response = ''.join([SOMEONELEFT, " "])
 213
 214                 the_name = ''
 215                 for name in members.keys():
 216                     if members[name] == (host, port):
 217                         the_name = name
 218
 219                 self.ejectMember(the_name)
 220
 221             else:
 222                 print "Messenger.datagramReceived(): IMOUT received, but sender not present in listing"
 223
 224         if data[:len(GETLIST)] == GETLIST:
 225             print "Messenger.datagramReceived(): GETLIST received, responding with LIST"
 226
 227             response = ''.join([LIST, ' '])
 228
 229             for iname in members:
 230                 if iname != name:
 231                     response = ''.join([response, iname, ' '])
 232
 233             self.transport.write(response, members[name])
 234
 235         if data[:len(SERVERKILL)] == SERVERKILL:
 236
 237             if data[len(SERVERKILL) + 1:] == parsed_config['password']:
 238                 print "Messenger.datagramReceived(): SERVERKILL received, dying now."
 239                 reactor.stop()
 240
 241         if data[:len(LETTER)] == LETTER:
 242
 243             responses = []
 244
 245             origin = ''
 246
 247             for name in members:
 248                 if members[name] == (host, port):
 249                     origin = name
 250
 251             if origin == '':
 252                 print "Messenger.datagramReceived(): LETTER received, but originator not in listing"
 253             else:
 254                 print "Messenger.datagramReceived(): LETTER received, forwarding it on..."
 255
 256                 response = [''.join([LETTER, ':', origin, ':']), []]
 257                 message = ''
 258
 259                 if data[len(LETTER):len(LETTER) + 2] == '::':
 260
 261                     message = data[data.find("::") + 2:]
 262                     response[0] = ''.join([response[0], message])
 263
 264                     for name in members:
 265                         if origin != name:
 266
 267                             responses.append(response)
 268                             response[-1][1] = members[name]
 269                 else:
 270
 271                     message = data[the_data.find(':', data.find(':') + 1) + 1:]
 272                     response[0] = ''.join([response[0], messsage])
 273
 274                     string_parts = data[data.find(':') + 1:
 275                                         data.find(':', data.find(':') + 1)].split()
 276
 277                     for dest in string_parts:
 278
 279                         if members.has_key(dest):
 280
 281                             responses.append(response)
 282                             responses[-1][1] = members[dest]
 283
 284                 for response_i in responses:
 285
 286                     self.transport.write(response_i[0], response_i[1])
 287
 288         return
 289
 290     def ejectMember(self, name):
 291
 292         if name in members.keys():
 293             response = YOUROUT
 294             self.transport.write(response, members[name])
 295
 296             del members[name]
 297
 298             response = ''.join([SOMEONELEFT, " ", name])
 299
 300             for member in members:
 301
 302                 self.transport.write(response, members[member])
 303
 304         return
 305
 306     def echo_request(self):
 307
 308         global members
 309         global parsed_config
 310
 311         for member in members:
 312             if member in self.echo_members:
 313
 314                 self.ejectMember(member)
 315
 316             else:
 317                 self.transport.write(YOUTHERE, members[member])
 318                 self.echo_members.append(member)
 319
 320         return
 321
 322 if __name__ == '__main__':
 323     main()