traipse_dev: orpg/networking/mplay

comparison orpg/networking/mplay_server.py @ 56:c7f04d3c76f5 traipse_dev

Major update to Server GUI. Basically makes it functional.

author	sirebral
date	Fri, 07 Aug 2009 21:53:14 -0500
parents	4385a7d0efd1
children	9014d7861bb3

comparison

equal deleted inserted replaced

-:0b79d5dbbe9e
+:c7f04d3c76f5
 # try to use it.
 try:
 self.configDom = minidom.parse(self.userPath + 'server_ini.xml')
 self.configDom.normalize()
 self.configDoc = self.configDom.documentElement
-# Obtain the lobby/server password if it's been specified
-if self.configDoc.hasAttribute("admin"):
+if hasattr(self, 'bootPassword'): self.boot_pwd = self.bootPassword
-self.boot_pwd = self.configDoc.getAttribute("admin")
-elif self.configDoc.hasAttribute("boot"):
+else:
-self.boot_pwd = self.configDoc.getAttribute("boot")
+if self.configDoc.hasAttribute("admin"): self.boot_pwd = self.configDoc.getAttribute("admin")
-if hasattr(self, 'bootPassword'):
+elif self.configDoc.hasAttribute("boot"): self.boot_pwd = self.configDoc.getAttribute("boot")
-self.boot_pwd = self.bootPassword
-elif len(self.boot_pwd) < 1:
+if len(self.boot_pwd) < 1: self.boot_pwd = raw_input("Enter admin password:  ")
-self.boot_pwd = raw_input("Enter boot password for the Lobby:  ")
 if not hasattr(self, 'reg') and self.configDoc.hasAttribute("register"):
 self.reg = self.configDoc.getAttribute("register")
 if not len(self.reg) > 0 or self.reg[0].upper() not in ("Y", "N"):
 opt = raw_input("Do you want to post your server to the OpenRPG Meta Server list? (y,n) ")
-if len(opt) and (opt[0].upper() == 'Y'):
+if len(opt) and (opt[0].upper() == 'Y'): self.reg = 'Y'
-self.reg = 'Y'
+else: self.reg = 'N'
-else:
-self.reg = 'N'
 LobbyName = 'Lobby'
-if self.configDoc.hasAttribute("lobbyname"):
+if self.configDoc.hasAttribute("lobbyname"): LobbyName = self.configDoc.getAttribute("lobbyname")
-LobbyName = self.configDoc.getAttribute("lobbyname")
 map_node = service_node = self.configDoc.getElementsByTagName("map")[0]
 msg_node = service_node = self.configDoc.getElementsByTagName("message")[0]
 mapFile = map_node.getAttribute('file')
 msgFile = msg_node.getAttribute('file')
-if mapFile == '':
+if mapFile == '': mapFile = 'Lobby_map.xml'
-mapFile = 'Lobby_map.xml'
+if msgFile == '': msgFile = 'LobbyMessage.html'
-if msgFile == '':
-msgFile = 'LobbyMessage.html'
 # Update the lobby with the passwords if they've been specified
 if len(self.boot_pwd):
 self.groups = {'0': game_group( '0', LobbyName, "", 'The game lobby', self.boot_pwd, "",
 self.userPath + mapFile.replace("myfiles/", ""),
 self.userPath + msgFile.replace("myfiles/", ""), 1 )
 # set ip or dns name to send to meta server
 service_node = self.configDoc.getElementsByTagName("service")[0]
 address = service_node.getAttribute("address")
 address = address.lower()
-if address == "" or address == "hostname/address" or address == "localhost":
+if address == "" or address == "hostname/address" or address == "localhost": self.server_address = None
-self.server_address = None
+else: self.server_address = address
-else:
-self.server_address = address
 self.server_port = OPENRPG_PORT
-if service_node.hasAttribute("port"):
+if service_node.hasAttribute("port"): self.server_port = int(service_node.getAttribute("port"))
-self.server_port = int(service_node.getAttribute("port"))
 if self.configDoc.hasAttribute("name") and len(self.configDoc.getAttribute("name")) > 0 :
 self.name = self.configDoc.getAttribute("name")
 else:
 if self.reg[0].upper() == "Y":
-if self.name == None:
+if self.name == None: self.name = raw_input("Server Name? ")
-self.name = raw_input("Server Name? ")
 self.register()
 # Get the minimum openrpg version from config if available
 # if it isn't set min version to internal default.
 #
 # server_ini.xml entry for version tag...
 # <version min="x.x.x">
 try:
 mver = self.configDoc.getElementsByTagName("version")[0]
 self.minClientVersion = mver.getAttribute("min")
-except:
+except: self.minClientVersion = SERVER_MIN_CLIENT_VERSION #from orpg/orpg_version.py
-self.minClientVersion = SERVER_MIN_CLIENT_VERSION #from orpg/orpg_version.py
 self.defaultMessageFile = ""
 # This try/except bit is to allow older versions of python to continue without a list error.
 # <autokick silent=["no","yes"] delay="(# of seconds)">
 try:
 ak = self.configDoc.getElementsByTagName("autokick")[0]
 if ak.hasAttribute("silent"):
-if ((ak.getAttribute("silent")).lower() == "yes"):
+if ((ak.getAttribute("silent")).lower() == "yes"): self.silent_auto_kick = 1
-self.silent_auto_kick = 1
+else: self.silent_auto_kick = 0
-else:
-self.silent_auto_kick = 0
 if ak.hasAttribute("delay"):
 try:
 delay = int(ak.getAttribute("delay"))
 self.zombie_time = delay
 except:
 setting = roomdefaults.getElementsByTagName('passwords')[0]
 rpw = setting.getAttribute('allow')
 if rpw == "no" or rpw == "0":
 roomdefault_pass = 0
 self.log_msg("Room Defaults: Disallowing Passworded Rooms")
-else:
+else: self.log_msg("Room Defaults: Allowing Passworded Rooms")
-self.log_msg("Room Defaults: Allowing Passworded Rooms")
+except: self.log_msg("Room Defaults: [Warning] Allowing Passworded Rooms")
-except:
-self.log_msg("Room Defaults: [Warning] Allowing Passworded Rooms")
 try:
 setting = roomdefaults.getElementsByTagName('map')[0]
 map = setting.getAttribute('file')
 if map != "":
 roomdefault_map = self.userPath + map.replace("myfiles/", "")
 try:
 setting = roomdefaults.getElementsByTagName('message')[0]
 msg = setting.getAttribute('file')
 if msg != "":
-if msg[:4].lower() == 'http':
+if msg[:4].lower() == 'http': roomdefault_msg = msg
-roomdefault_msg = msg
+else: roomdefault_msg = self.userPath + msg.replace("myfiles/", "")
-else:
-roomdefault_msg = self.userPath + msg.replace("myfiles/", "")
 self.log_msg("Room Defaults: Using " + str(msg) + " for room messages")
-except:
+except: print ("Room Defaults: [Warning] Using Default Message")
-print ("Room Defaults: [Warning] Using Default Message")
 except:
 traceback.print_exc()
 self.log_msg("**WARNING** Error loading default room settings from configuration file. Using internal defaults.")
 #set the defaults
 if roomdefault_msg != "" or roomdefault_msg != None:
 self.defaultMessageFile = roomdefault_msg  #<room_defaults> tag superceeds older <newrooms> tag
-else:
+else: self.defaultMessageFile = None
-self.defaultMessageFile = None
 if roomdefault_map != "" or roomdefault_map != None:
 self.defaultMapFile = roomdefault_map  #<room_defaults> tag superceeds older <newrooms> tag
-else:
+else: self.defaultMapFile = None
-self.defaultMapFile = None
 ##### room default map not handled yet. SETTING IGNORED
 if roomdefault_pass == 0: self.allow_room_passwords = 0
 else: self.allow_room_passwords = 1
 # should validate protocal
 validate_protocol_node = self.configDom.getElementsByTagName("validate_protocol ")
 self.validate_protocol = 1
-if(validate_protocol_node):
+if(validate_protocol_node): self.validate_protocol = (validate_protocol_node[0].getAttribute("value") == "True")
-self.validate_protocol = (validate_protocol_node[0].getAttribute("value") == "True")
+if(self.validate_protocol != 1): self.log_msg("Protocol Validation: OFF")
-if(self.validate_protocol != 1):
-self.log_msg("Protocol Validation: OFF")
 self.makePersistentRooms()
 self.log_msg("Server Configuration File: Processing Completed.")
 except Exception, e:
 roomName = element.getAttribute('name')
 roomPassword = element.getAttribute('password')
 bootPassword = element.getAttribute('boot')
 # Conditionally check for minVersion attribute
-if element.hasAttribute('minVersion'):
+if element.hasAttribute('minVersion'): minVersion = element.getAttribute('minVersion')
-minVersion = element.getAttribute('minVersion')
+else: minVersion = ""
-else:
-minVersion = ""
 # Extract the map filename attribute from the map node
 # we only care about the first map element found -- others are ignored
 mapElement = element.getElementsByTagName('map')[0]
 mapFile = self.userPath + mapElement.getAttribute('file').replace("myfiles/", "")
 messageElement = element.getElementsByTagName('message')[0]
 messageFile = messageElement.getAttribute('file')
-if messageFile[:4] != 'http':
+if messageFile[:4] != 'http': messageFile = self.userPath + messageFile.replace("myfiles/", "")
-messageFile = self.userPath + messageFile.replace("myfiles/", "")
 # Make sure we have a message to even mess with
-if(len(messageFile) == 0):
+if(len(messageFile) == 0): messageFile = self.defaultMessageFile
-messageFile = self.defaultMessageFile
+if(len(mapFile) == 0): mapFile = self.defaultMapFile
-if(len(mapFile) == 0):
-mapFile = self.defaultMapFile
 moderated = 0
-if element.hasAttribute('moderated') and element.getAttribute('moderated').lower() == "true":
+if element.hasAttribute('moderated') and element.getAttribute('moderated').lower() == "true": moderated = 1
-moderated = 1
 #create the new persistant group
 self.new_group(roomName, roomPassword, bootPassword, minVersion, mapFile, messageFile, persist = 1, moderated=moderated)
 self.log_msg("Network Logging: ON (split logfiles)")
 self.log_network_messages = 2
 else: return
 #when log mode changes update all connection stubs
 for n in self.players:
-try:
+try: self.players[n].EnableMessageLogging = mode
-self.players[n].EnableMessageLogging = mode
+except: self.log_msg("Error changing Message Logging Mode for client #" + str(self.players[n].id))
-except:
-self.log_msg("Error changing Message Logging Mode for client #" + str(self.players[n].id))
 def NetworkLoggingStatus(self):
 if self.log_network_messages == 0: return "Network Traffic Log: Off"
 elif self.log_network_messages == 1: return "Network Traffic Log: Logging (composite file)"
 elif self.log_network_messages == 2: return "Network Traffic Log: Logging (inbound/outbound files)"
 else: self.log_msg("Network Traffic Log: [Unknown]")
 newlist = getRawMetaList()      #  read it into a second list
 finally:
 metacache_lock.release()
 if newlist != curlist:          #  If the two lists aren't identical
 #  then something has changed.
 instance.register()             #  Call self.register()
 #  which will force a re-read of the meta cache and
 #  redo the registerThreads
-else:
+else: instance.register()
-instance.register()
 # Eventually, reset the MetaServerBaseURL here
 ## Added to help clean up parser errors in the XML on clients
 ## due to characters that break welformedness of the XML from
 ## the meta server.
 ## NOTE: this is a stopgap measure -SD
 def clean_published_servername(self, name):
 #clean name of all apostrophes and quotes
 badchars = "\"\\`><"
-for c in badchars:
+for c in badchars: name = name.replace(c,"")
-name = name.replace(c,"")
 return name
 def registerRooms(self, args=None):
 rooms = ''
 id = '0'
 "act":'registerrooms'})
 get_server_dom(data+'&'+rooms, self.metas[meta].path)
 def register(self,name_given=None):
-if name_given == None:
+if name_given == None: name = self.name
-name = self.name
+else: self.name = name = name_given
-else:
-self.name = name = name_given
 name = self.clean_published_servername(name)
 #  Set up the value for num_users
-if self.players:
+if self.players: num_players = len(self.players)
-num_players = len(self.players)
+else: num_players = 0
-else:
-num_players = 0
 #  request only Meta servers compatible with version 2
 metalist = getMetaServers(versions=["2"])
 if self.show_meta_messages != 0:
 self.log_msg("Found these valid metas:")
-for meta in metalist:
+for meta in metalist: self.log_msg("Meta:" + meta)
-self.log_msg("Meta:" + meta)
 #  Go through the list and see if there is already a running register
 #  thread for the meta.
 #  If so, call it's register() method
 #  If not, start one, implicitly calling the new thread's register() method
 if self.show_meta_messages != 0: self.log_msg("meta:" + meta + ": ")
 if not meta in metalist:  # if the meta entry running is not in the list
 if self.show_meta_messages != 0: self.log_msg( "Outdated.  Unregistering and removing")
 self.metas[meta].unregister()
 del self.metas[meta]
 else:
 if self.show_meta_messages != 0: self.log_msg( "Found in current meta list.  Leaving intact.")
 #  Now call register() for alive metas or start one if we need one
 for meta in metalist:
 if self.metas.has_key(meta) and self.metas[meta] and self.metas[meta].isAlive():
 #  would never get unregistered.
 #
 #  Instead, loop through all existing meta threads and unregister them
 for meta in self.metas.values():
-if meta and meta.isAlive():
+if meta and meta.isAlive(): meta.unregister()
-meta.unregister()
 self.be_registered = 0
+#  This method runs as it's own thread and does the group_member_check every
+#    sixty seconds.  This should eliminate zombies that linger when no one is
+#    around to spook them.  GC: Frequency has been reduced as I question how valid
-#  This method runs as it's own thread and does the group_member_check every
+#    the implementation is as it will only catch a very small segment of lingering
-#    sixty seconds.  This should eliminate zombies that linger when no one is
+#    connections.
-#    around to spook them.  GC: Frequency has been reduced as I question how valid
-#    the implementation is as it will only catch a very small segment of lingering
-#    connections.
 def player_reaper_thread_func(self,arg):
 while self.alive:
 time.sleep(60)
 self.p_lock.acquire()
-for group in self.groups.keys():
+for group in self.groups.keys(): self.check_group_members(group)
-self.check_group_members(group)
 self.p_lock.release()
 #This thread runs ever 250 miliseconds, and checks various plugin stuff
 def PluginThread(self):
 while self.alive:
 self.p_lock.acquire()
 players = ServerPlugins.getPlayer()
 for player in players:
-if player is not None:
+if player is not None: pass #Do something here so they can show up in the chat room for non web users'
-#Do something here so they can show up in the chat room for non web users'
-pass
 data = ServerPlugins.preParseOutgoing()
 for msg in data:
 try:
 xml_dom = parseXml(msg)
 xml_dom = xml_dom._get_documentElement()
 xml_dom.setAttribute('from', '-1')
 xml_dom.setAttribute('to', 'all')
 self.incoming_msg_handler(xml_dom, msg)
 xml_dom.unlink()
-except:
+except: pass
-pass
 self.p_lock.release()
 time.sleep(0.250)
 while offset < len(mpacket):
 slice = buffer(mpacket, offset, len(mpacket)-offset)
 sent = sock.send(slice)
 offset += sent
 sentm = offset
 else:
-# Calculate our message length
+length = len( msg ) # Calculate our message length
-length = len( msg )
+lp = pack('!i', length) # Encode the message length into network byte order
-# Encode the message length into network byte order
-lp = pack('!i', length)
 try:
-# Send the encoded length
+sentl = sock.send( lp ) # Send the encoded length
-sentl = sock.send( lp )
+sentm = sock.send( msg ) # Now, send the message the the length was describing
+except socket.error, e: self.log_msg( e )
-# Now, send the message the the length was describing
+except Exception, e: self.log_msg( e )
-sentm = sock.send( msg )
-except socket.error, e:
-self.log_msg( e )
-except Exception, e:
-self.log_msg( e )
 def recvData( self, sock, readSize ):
 """Simple socket receive method.  This method will only return when the exact
 byte count has been read from the connection, if remote terminates our
 data = ""
 offset = 0
 try:
 while offset != readSize:
 frag = sock.recv( readSize - offset )
+rs = len( frag ) # See if we've been disconnected
-# See if we've been disconnected
-rs = len( frag )
 if rs <= 0:
 # Loudly raise an exception because we've been disconnected!
 raise IOError, "Remote closed the connection!"
+else: # Continue to build complete message
-else:
-# Continue to build complete message
 offset += rs
 data += frag
 except socket.error, e:
 self.log_msg("Socket Error: recvData(): " +  e )
 data = ""
 return data
 def recvMsg(self, sock, useCompression=False, cmpType=None):
 """This method now expects to receive a message having a 4-byte prefix length.  It will ONLY read
 completed messages.  In the event that the remote's connection is terminated, it will throw an
 exception which should allow for the caller to more gracefully handles this exception event.
 with the OS until we attempt to read the next complete message."""
 msgData = ""
 try:
 lenData = self.recvData( sock, MPLAY_LENSIZE )
 # Now, convert to a usable form
 (length,) = unpack('!i', lenData)
 # Read exactly the remaining amount of data
 msgData = self.recvData( sock, length )
 try:
-if useCompression and cmpType != None:
+if useCompression and cmpType != None: msgData = cmpType.decompress(msgData)
-msgData = cmpType.decompress(msgData)
+except: traceback.print_exc()
-except:
-traceback.print_exc()
+except Exception, e: self.log_msg( "Exception: recvMsg(): " + str(e) )
-except Exception, e:
-self.log_msg( "Exception: recvMsg(): " + str(e) )
 return msgData
 def kill_server(self):
 self.alive = 0
 self.log_msg("Server stopping...")
 # Re-initialize the role for this player incase they came from a different server
 self.handle_role("set",props['id'], "GM",self.groups[LOBBY_ID].boot_pwd, LOBBY_ID)
 cmsg = "Client Connect: (" + str(props['id']) + ") " + str(props['name']) + " [" + str(props['ip']) + "]"
+self.log_msg(cmsg)
+cmsg = ("connect", props) #################################################
 self.log_msg(cmsg)
 #  If already registered then re-register, thereby updating the Meta
 #    on the number of players
 if self.be_registered:
 # this line sends a handle role message to change the players role
 self.send_player_list(from_id,group_id)
 #notify user about others in the room
 self.return_room_roles(from_id,group_id)
-self.log_msg(("join_group", (from_id, group_id)))
+self.log_msg(("join_group", (self.groups[group_id].name, group_id, from_id)))
 self.handle_role("set", from_id, self.players[from_id].role, self.groups[group_id].boot_pwd, group_id)
 except Exception, e:
 self.log_msg(str(e))
 # send them to players.  Also note, both these methods have race
 # conditions written all over them.  Ack! Ack!
 def new_group( self, name, pwd, boot, minVersion, mapFile, messageFile, persist = 0, moderated=0 ):
 group_id = str( self.next_group_id )
 self.next_group_id += 1
 self.groups[group_id] = game_group( group_id, name, pwd, "", boot, minVersion, mapFile, messageFile, persist )
 self.groups[group_id].moderated = moderated
 ins = ""
 if persist !=0: ins="Persistant "
 lmsg = "Creating " + ins + "Group... (" + str(group_id) + ") " + str(name)
 self.log_msg( lmsg )
+self.log_msg(("create_group", (str(name), int(group_id), 0) )) ##-99 works, could be better.
 def change_group_name(self,gid,name,pid):
 "Change the name of a group"
 # Check for & in name.  We want to allow this because of its common
 self.handle_role("set",from_id,"GM",boot_pwd, group_id)
 lmsg = "Creating Group... (" + str(group_id) + ") " + str(name)
 self.log_msg( lmsg )
 jmsg = "moving to room " + str(group_id) + "."
 self.log_msg( jmsg )
+self.log_msg(("create_group", (str(name), group_id, from_id)))
 #even creators of the room should see the HTML --akoman
 #edit: jan10/03 - was placed in the except statement. Silly me.
 if self.defaultMessageFile != None:
 if self.defaultMessageFile[:4] == 'http':
 data = urllib.urlretrieve(self.defaultMessageFile)
 self.send_to_all("0",self.groups[group_id].toxml('update'))
 return #never remove lobby *sanity check*
 if not self.isPersistentRoom(group_id)  and self.groups[group_id].get_num_players() == 0:
 self.send_to_all("0",self.groups[group_id].toxml('del'))
 del self.groups[group_id]
-self.log_msg(("delete_group", (from_id, group_id)))
+self.log_msg(("delete_group", (group_id, from_id)))
 else:
 self.send_to_all("0",self.groups[group_id].toxml('update'))
 #The register Rooms thread
 dmsg = "Client Disconnect: (" + str(id) + ") " + str(self.players[id].name)
 self.players[id].disconnect()
 self.groups[group_id].remove_player(id)
 del self.players[id]
 self.log_msg(dmsg)
+self.log_msg(("disconnect",id))
 #  If already registered then re-register, thereby updating the Meta
 #    on the number of players
 #  Note:  Upon server shutdown, the server is first unregistered, so
 self.players[player].send(msg,player,group)
 def send_to_all(self,from_id,data):
 try:
+print data
 self.p_lock.acquire()
 keys = self.players.keys()
 self.p_lock.release()
 for k in keys:
 if k != from_id:
 self.players[k].outbox.put(data)
 except Exception, e:
 traceback.print_exc()
 self.log_msg("Exception: send_to_all(): " + str(e))
 def send_to_group(self, from_id, group_id, data):
-data = ServerPlugins.postParseIncoming(data)
+msg = ("<msg to='all' from='0' group_id='"+group_id+"'><font color='#FF0000'>" + data + "</font>")
-try:
+#data = ServerPlugins.postParseIncoming(data)
+try:
+print data
+self.p_lock.acquire()
 keys = self.groups[group_id].get_player_ids()
+self.p_lock.release()
+print keys
 for k in keys:
 if k != from_id:
-self.players[k].outbox.put(data)
+self.players[k].outbox.put(msg)
 except Exception, e:
 traceback.print_exc()
 self.log_msg("Exception: send_to_group(): " + str(e))
 def send_player_list(self,to_id,group_id):

Mercurial > traipse_dev

comparison orpg/networking/mplay_server.py @ 56:c7f04d3c76f5 traipse_dev