server.py

   1 #!/usr/bin/python
   2
   3 import os, sys
   4 from os.path import *
   5
   6 import threading
   7 from socket import *
   8 from xml.dom.minidom import parse, parseString
   9 from threading import Lock
  10 from signal import *
  11
  12 CONFIG = 'config.xml'
  13
  14 BROADCAST = 50030
  15 MESSAGE = 40031
  16 PASSWORD = "changethis"
  17 NAME = "default"
  18
  19 BUFSIZE = 120
  20
  21 # this will change
  22
  23 SERVERREQUEST = "i_want_server"
  24 SERVEROFFER = "Want_server?"
  25 SERVERKILL = "DIE_server!!"
  26 YOUTHERE = "you_there?"
  27 IMHERE = "yeah,i'm_here"
  28 WANTIN = "i_want_in"
  29 YOUREIN = "urine"
  30 IMOUT = "i_leave"
  31 GETLIST = "get_list"
  32 LIST = "peoples_on_server"
  33 SOMEONEJOINED = "dude,someone_joined"
  34 SOMEONELEFT = "someone_left"
  35 YOUROUT = "get_lost_punk"
  36 LETTER = "listen_to_me"
  37
  38 # end changes
  39
  40 TIMEOUT = .1
  41
  42 my_server = 0
  43
  44 class Server:
  45
  46     def __init__(self, config):
  47
  48         self.running = 1
  49
  50         self.outgoing = []
  51         self.incoming = []
  52
  53         self.outgoing_lock = Lock()
  54         self.incoming_lock = Lock()
  55
  56         self.broadcast = socket(AF_INET, SOCK_DGRAM)
  57         self.message = socket(AF_INET, SOCK_DGRAM)
  58
  59         self.message_lock = Lock()
  60
  61         self.members = {}
  62
  63         self.configuration = config
  64
  65         if (config.has_key('broadcast')):
  66             self.broadcast.bind(('', config['broadcast']))
  67         else:
  68             print "Server.__init__(): No broadcast socket number chosen, using", BROADCAST
  69             self.broadcast.bind(('', BROADCAST))
  70
  71         if (config.has_key('message')):
  72             self.message.bind(('', config['message']))
  73         else:
  74             print "Server.__init__(): No message socket number chosen, using", MESSAGE
  75             self.message.bind(('', MESSAGE))
  76
  77     def receive(self):
  78
  79         print "Server.receive() beginning..."
  80
  81         self.message.settimeout(TIMEOUT)
  82
  83         while (self.running):
  84             try:
  85                 self.message_lock.acquire()
  86                 data_in = self.message.recvfrom(BUFSIZE)
  87                 self.message_lock.release()
  88             except:
  89                 data_in = ()
  90
  91             if (data_in != ()):
  92                 self.incoming_lock.acquire()
  93                 self.incoming.append(data_in)
  94                 print "Got data", data_in
  95                 self.incoming_lock.release()
  96
  97             return
  98
  99     def send(self):
 100
 101         print "Server.send() beginning..."
 102
 103         while (self.running):
 104
 105             if (len(self.outgoing)):
 106
 107                 self.outgoing_lock.acquire()
 108                 print "Server.send(): Acquired outgoing_lock"
 109
 110                 data_out = self.outgoing.pop(0)
 111
 112                 self.outgoing_lock.release()
 113                 print "Server.send(): Released outgoing_lock"
 114
 115                 self.message.sendto(data_out[0], data_out[1])
 116                 print "Server.send(): Sent data", data_out
 117         return
 118
 119     def process_in(self):
 120
 121         print "Server.process_in() beginning..."
 122
 123         while (self.running):
 124
 125             if (len(self.incoming)):
 126                 # data in = ()
 127
 128                 self.incoming_lock.acquire()
 129                 print "Server.process_in(): Acquired incoming_lock"
 130
 131                 data_in = self.incoming.pop(0)
 132
 133                 self.incoming_lock.release()
 134                 print "Server.process_in(): Released incoming_lock"
 135
 136                 if (data_in[0][:len(WANTIN)] == WANTIN):
 137                     print "Server.process_in(): Received WANTIN"
 138
 139                     response = [YOUREIN, data_in[1]]
 140
 141                     self.outgoing_lock.acquire()
 142                     print "Server.process_in(): Acquired outgoing_lock"
 143
 144                     self.outgoing.append(response)
 145
 146                     self.outgoing_lock.release()
 147                     print "Server.process_in(): Released outgoing_lock"
 148
 149                     self.members[data_in[0][len(WANTIN) + 1:]] = data_in[1]
 150
 151                 if (data_in[0][:len(YOUTHERE)] == YOUTHERE):
 152                     print "Server.process_in(): Received YOUTHERE, responding with IMHERE"
 153
 154                     response = [IMHERE, data_in[1]]
 155
 156                     self.outgoing_lock.acquire()
 157                     print "Server.process_in(): Acquired outgoing_lock"
 158
 159                     self.outgoing.append(response)
 160
 161                     self.outgoing_lock.release()
 162                     print "Server.process_in(): Released outgoing_lock"
 163
 164                 if (data_in[0][:len(IMOUT)] == IMOUT):
 165                     print "Server.process_in(): Received IMOUT, notifying clients"
 166
 167                     response = []
 168                     name_to_delete = ''
 169
 170                     for name, address in self.members.iteritems():
 171                         if (data_in[1] == address):
 172                             response[0] = SOMEONELEFT + " " + name
 173                             name_to_delete = name
 174
 175                     if (name_to_delete != ''):
 176                         del self.members[name_to_delete]
 177
 178                         for name, address in self.members.iteritems():
 179                             response[1] = address
 180
 181                             self.outgoing_lock.acquire()
 182                             print "Server.process_in(): Acquired outgoing_lock"
 183
 184                             self.outgoing.append(response)
 185
 186                             self.outgoing_lock.release()
 187                             print "Server.process_in(): Released outgoing_lock"
 188
 189                 if (data_in[0] == GETLIST):
 190                     print "Server.process_in(): Received GETLIST, responding with member list"
 191
 192                     for name, address in self.members.iteritems():
 193                         if (address == data_in[1]):
 194                             response = []
 195
 196                             response[0] = LIST + " "
 197                             response[1] = address
 198
 199                             for iname, iaddress in self.members.iteritems():
 200                                 if (iname != name):
 201                                     response[0] = response[0] + iname + " "
 202
 203                             self.outgoing_lock.acquire()
 204
 205                             print "Server.process_in(): Acquired outgoing_lock"
 206
 207                             self.outgoing.append(response)
 208
 209                             self.outgoing_lock.release()
 210                             print "Server.process_in(): Released outgoing_lock"
 211
 212                 if (data_in[0][:len(SERVERKILL)] == SERVERKILL):
 213                     print "Server.process_in(): Received SERVERKILL"
 214
 215                     if (data_in[0][len(SERVERKILL) + 1:] == self.configuration['password']):
 216                         self.running = 0
 217
 218                 if (data_in[0][:len(LETTER)] == LETTER):
 219                     print "Server.process_in(): Received LETTER"
 220
 221                     responses = []
 222
 223                     the_data = data_in[0]
 224                     it_is = ''
 225
 226                     origin = ''
 227
 228                     for name in self.members.keys():
 229                         if self.members[name] == data_in[1]:
 230                             origin = name
 231
 232                     if origin != '':
 233
 234                         response = [LETTER + ":" + origin + ":", []]
 235
 236                         if the_data[len(LETTER):len(LETTER)+2] == '::':
 237
 238                             it_is = the_data[the_data.find("::") + 2:]
 239                             response[0] += it_is
 240
 241                             for name in self.members.keys():
 242
 243                                 if origin != name:
 244
 245                                     responses.append(response)
 246                                     responses[-1][1] = self.members[name]
 247
 248                         else:
 249
 250                             it_is = the_data[the_data.find(":", the_data.find(":") + 1) + 1:]
 251                             response[0] += it_is
 252
 253                             string_parts = the_data[the_data.find(":") + 1:
 254                                                     the_data.find(":", the_data.find(":") + 1)].split()
 255
 256                             for dest in string_parts:
 257
 258                                 if self.members.has_key(dest):
 259
 260                                     responses.append(response)
 261                                     responses[-1][1] = self.members[dest]
 262
 263                         for response_i in responses:
 264
 265                             self.outgoing_lock.acquire()
 266                             self.outgoing.append(response_i)
 267                             self.outgoing_lock.release()
 268
 269         return
 270
 271     def process_out(self):
 272
 273         print "Server.process_out(): Not implemented yet."
 274
 275         return
 276
 277     def broadcast_listen(self):
 278
 279         print "Listening on broadcast port:", self.configuration['broadcast']
 280
 281         broadcast_message = SERVEROFFER + " " + str(self.configuration['message'])
 282         broadcast_message = broadcast_message + " " + self.configuration['name']
 283
 284         while (self.running):
 285             data_in = self.broadcast.recvfrom(BUFSIZE)
 286
 287             if (data_in[0][0:len(SERVERREQUEST)] == SERVERREQUEST):
 288                 new_message = [broadcast_message]
 289                 new_message.append((data_in[1][0], int(data_in[0][len(SERVERREQUEST) + 1:])))
 290
 291                 self.outgoing_lock.acquire()
 292                 print "Server.broadcast_listen(): Acquired outgoing_lock"
 293
 294                 self.outgoing.append(new_message)
 295
 296                 self.outgoing_lock.release()
 297                 print "Server.broadcast_listen(): Released outgoing_lock"
 298
 299         return
 300
 301     def end_it(self):
 302         self.running = 0
 303         return
 304
 305 def parse_config(filename):
 306
 307     parsed = {'error': 1}
 308
 309     if (exists(filename)):
 310         dom = parse(filename)
 311     else:
 312         print "parse_config():", filename, "doesn't exist"
 313         return parsed
 314
 315     if (dom.childNodes[0].nodeName == 'server_config'):
 316         for node in dom.childNodes[0].childNodes:
 317
 318             if (node.nodeName == 'name' and len(node.childNodes)):
 319                 parsed['name'] = node.childNodes[0].nodeValue
 320
 321             if (node.nodeName == 'password' and len(node.childNodes)):
 322                 parsed['password'] = node.childNodes[0].nodeValue
 323
 324             if (node.nodeName == 'broadcast' and len(node.childNodes)):
 325                 parsed['broadcast'] = int(node.childNodes[0].nodeValue)
 326
 327             if (node.nodeName == 'message' and len(node.childNodes)):
 328                 parsed['message'] = int(node.childNodes[0].nodeValue)
 329
 330     parsed['error'] = 0
 331
 332     return parsed
 333
 334 def run(configuration):
 335
 336     my_server = Server(configuration)
 337
 338     receive_thread = threading.Thread(target=my_server.receive)
 339     send_thread = threading.Thread(target=my_server.send)
 340     process_in_thread = threading.Thread(target=my_server.process_in)
 341     process_out_thread = threading.Thread(target=my_server.process_out)
 342     broadcast_thread = threading.Thread(target=my_server.broadcast_listen)
 343
 344     receive_thread.start()
 345     send_thread.start()
 346     broadcast_thread
 347     process_in_thread.start()
 348     process_out_thread.start()
 349     broadcast_thread.start()
 350
 351     receive_thread.join()
 352     send_thread.join()
 353     broadcast_thread.join()
 354     process_in_thread.join()
 355     process_out_thread.join()
 356
 357     return
 358
 359 def handler(signal, frame):
 360     if (signal == SIGINT):
 361         my_server.end_it()
 362         print "It should have ended"
 363
 364 def main():
 365
 366     # parsing command line options
 367
 368     if (len(sys.argv) > 1):
 369         config_file = sys.argv[1]
 370     else:
 371         print "main(): No config file specified, using", CONFIG
 372         config_file = CONFIG
 373
 374     parsed_config = parse_config(config_file)
 375
 376     if (parsed_config['error']):
 377         print "main(): Error parsing config, ending"
 378         return
 379
 380     signal(SIGINT, handler)
 381
 382     run(parsed_config)
 383
 384 if __name__ == '__main__':
 385     main()