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