traipse: orpg/networking/mplay_messaging.py comparison

comparison orpg/networking/mplay_messaging.py @ 18:97265586402b ornery-orc

Traipse 'OpenRPG' {090827-00} Traipse is a distribution of OpenRPG that is designed to be easy to setup and go. Traipse also makes it easy for developers to work on code without fear of sacrifice. 'Ornery-Orc' continues the trend of 'Grumpy' and adds fixes to the code. 'Ornery-Orc''s main goal is to offer more advanced features and enhance the productivity of the user. Update Summary: Update Manager is now in version 0.8. While not every button works, users can now browse the different revisions and their different changesets. The code has been refined some with feature from Core added to it. A Crash report is now created if the users software crashes. Update Manager has been moved to the Traipse Suite menu item, and a Debug Console as been added as well.

author	sirebral
date	Thu, 27 Aug 2009 01:04:43 -0500
parents	4385a7d0efd1
children	ff154cf3350c

comparison

equal deleted inserted replaced

-:265b987cce4f
+:97265586402b
 import traceback
 from threading import Event, Lock
 from xml.sax.saxutils import escape
 from struct import pack, unpack, calcsize
 from string import *
-from orpg.orpg_version import *
+from orpg.orpg_version import VERSION, PROTOCOL_VERSION, CLIENT_STRING, SERVER_MIN_CLIENT_VERSION
 import os
 import time
-from orpg.orpgCore import *
+from orpg.tools.orpg_log import logger
+from orpg.orpgCore import component
 def myescape(data):
 return escape(data,{"\"":""})
 class messenger:
 def __init__(self, *args, **kwargs):
-self.log = open_rpg.get_component("log")
+#self.xml = component.get("xml") used once, no need for the object.
-self.xml = open_rpg.get_component("xml")
+self.dir_struct = component.get("dir_struct") #used?
-self.dir_struct = open_rpg.get_component("dir_struct")
+self.validate = component.get("validate") #used??
-self.validate = open_rpg.get_component("validate")
+#self.settings = component.get("settings") ## used once, no need for the object.
-self.settings = open_rpg.get_component("settings")
 if kwargs.has_key('isServer'):
 self.isServer = kwargs['isServer']
 else:
 self.isServer = False
 self.listen_event = Event()
 self.inbox = Queue.Queue(0)
 self.startedEvent = Event()
 self.exitEvent = Event()
 self.sendThreadExitEvent = Event()
 self.recvThreadExitEvent = Event()
-self.port = int(self.settings.get_setting("port"))
+self.port = int(component.get("settings").get_setting("port")) ##used even?
 self.ip = socket.gethostbyname(socket.gethostname())
 self.lensize = calcsize('i')
 self.mplay_type = ('disconnected', 'connected', 'disconnecting', 'group change', 'group change failed')
 self.status = self.mplay_type[0]
 self.alive = False
 message += ' />'
 return message
 def disconnect(self):
 self.set_status(2)
-self.log.log("client stub " + self.ip +" disconnecting...", ORPG_DEBUG)
+logger.debug("client stub " + self.ip +" disconnecting...")
-self.log.log("closing sockets...", ORPG_DEBUG)
+logger.debug("closing sockets...")
 try:
 self.sock.shutdown( 2 )
 except:
-self.log.log("Caught exception:\n" + traceback.format_exc(), ORPG_GENERAL)
+logger.general("Caught exception:\n" + traceback.format_exc())
 self.set_status(0)
 def reset(self, sock):
 self.disconnect()
 self.sock = sock
 def update_self_from_player(self, player):
 try:
 (self.name, self.ip, self.id, self.text_status, self.version, self.protocol_version, self.client_string,role) = player
 except:
-self.log.log("Exception:  messenger->update_self_from_player():\n" + traceback.format_exc(), ORPG_GENERAL)
+logger.general("Exception:  messenger->update_self_from_player():\n" + traceback.format_exc())
 def toxml(self, act):
-self.log.log("DEPRECIATED! messenger->toxml()", ORPG_CRITICAL)
+logger.exception("DEPRECIATED! messenger->toxml()")
 xml_data = self.build_message('player',
 name=myescape(self.name),
 action=act,
 id=self.id,
 group_id=self.group_id,
 #Message Handaling
 def message_handler(self, arg):
 xml_dom = None
-self.log.log("message handler thread running...", ORPG_NOTE)
+logger.note("message handler thread running...", ORPG_NOTE)
 while self.alive or self.status == 'connected':
 data = None
 try:
 data = self.inbox.get(0)
 except Queue.Empty:
 #data has been passed... unlink from the variable references
 #so data in passed objects doesn't change (python passes by reference)
 del data
 data = None
 except Exception, e:
-self.log.log(traceback.format_exc(), ORPG_GENERAL)
+logger.general(traceback.format_exc())
 if xml_dom: xml_dom.unlink()
 if xml_dom: xml_dom.unlink()
-self.log.log("message handler thread exiting...", ORPG_NOTE)
+logger.note("message handler thread exiting...")
 self.inbox_event.set()
 def parse_incoming_dom(self, data):
 #print data
 xml_dom = None
 try:
-xml_dom = self.xml.parseXml(data)
+xml_dom = component.get("xml").parseXml(data)
 xml_dom = xml_dom._get_documentElement()
 self.message_action(xml_dom, data)
 except Exception, e:
-self.log.log("Error in parse of inbound message. Ignoring message.", ORPG_GENERAL)
+logger.general("Error in parse of inbound message. Ignoring message.")
-self.log.log("\tOffending data(" + str(len(data)) + "bytes)=" + data, ORPG_GENERAL)
+logger.general("\tOffending data(" + str(len(data)) + "bytes)=" + data)
-self.log.log("Exception=" + traceback.format_exc(), ORPG_GENERAL)
+logger.general("Exception=" + traceback.format_exc())
 if xml_dom: xml_dom.unlink()
 def message_action(self, xml_dom, data):
 tag_name = xml_dom._get_tagName()
 if self.msg_handlers.has_key(tag_name):
 self.msg_handlers[tag_name](xml_dom, data)
 else:
-self.log.log("Unknown Message Type", ORPG_GENERAL)
+logger.general("Unknown Message Type")
-self.log.log(data, ORPG_GENERAL)
+logger.general(data)
 #Message Action thread expires and closes here.
 return
 #Privet functions
 def sendThread( self, arg ):
 while( self.get_status() == 'connected' ):
 try:
 readMsg = self.outbox.get( block=1 )
 except Exception, text:
-self.log.log("Exception:  messenger->sendThread():  " + str(text), ORPG_CRITICAL)
+logger.exception("Exception:  messenger->sendThread():  " + str(text)
 # If we are here, it's because we have data to send, no doubt!
 if self.status == 'connected':
 try:
 # Send the entire message, properly formated/encoded
 sent = self.sendMsg( self.sock, readMsg )
 except:
-self.log.log("Exception:  messenger->sendThread():\n" + traceback.format_exc(), ORPG_CRITICAL)
+logger.exception("Exception:  messenger->sendThread():\n" + traceback.format_exc()
 else:
 # If we are not connected, purge the data queue
-self.log.log("Data queued without a connection, purging data from queue...", ORPG_NOTE)
+logger.note("Data queued without a connection, purging data from queue...")
 self.sendThreadExitEvent.set()
-self.log.log( "sendThread has terminated...", ORPG_NOTE)
+logger.note( "sendThread has terminated...")
 def sendMsg( self, sock, msg ):
 """Very simple function that will properly encode and send a message to te
 remote on the specified socket."""
 sentl = sock.send( lp )
 # Now, send the message the the length was describing
 sentm = sock.send( msg )
 if self.isServer:
-self.log.log("('data_sent', " + str(sentl+sentm) + ")", ORPG_DEBUG)
+logger.debug("('data_sent', " + str(sentl+sentm) + ")")
 return sentm
 except socket.error, e:
-self.log.log("Socket Error: messenger->sendMsg(): " +  traceback.format_exc(), ORPG_CRITICAL)
+logger.exception("Socket Error: messenger->sendMsg(): " +  traceback.format_exc())
 except:
-self.log.log("Exception:  messenger->sendMsg(): " +  traceback.format_exc(), ORPG_CRITICAL)
+logger.exception("Exception:  messenger->sendMsg(): " +  traceback.format_exc())
 def recvThread( self, arg ):
 "Receiving thread.  This thread reads from the socket and writes to the data queue."
 # Wait to be told it's okay to start running
 else:
 # Pass along the message so it can be processed
 self.inbox.put( readMsg )
 self.update_idle_time() #update the last message time
 if bytes == 0:
-self.log.log("Remote has disconnected!", ORPG_NOTE)
+logger.note("Remote has disconnected!")
 self.set_status(2)
 self.outbox.put( "" )    # Make sure the other thread is woken up!
 self.sendThreadExitEvent.set()
-self.log.log("messenger->recvThread() has terminated...", ORPG_NOTE)
+logger.note("messenger->recvThread() has terminated...")
 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
 connection or we get some other socket exception."""
 else:
 # Continue to build complete message
 offset += rs
 data += frag
 except socket.error, e:
-self.log.log("Socket Error: messenger->recvData(): " +  str(e), ORPG_CRITICAL)
+logger.exception("Socket Error: messenger->recvData(): " +  str(e))
 data = ""
 return data
 def recvMsg( self, sock ):
 """This method now expects to receive a message having a 4-byte prefix length.  It will ONLY read
 # Read exactly the remaining amount of data
 msgData = self.recvData( sock, length )
 if self.isServer:
-self.log.log("('data_recv', " + str(length+4) + ")", ORPG_DEBUG)
+logger.debug("('data_recv', " + str(length+4) + ")")
 except:
-self.log.log("Exception: messenger->recvMsg():\n" + traceback.format_exc(), ORPG_CRITICAL)
+logger.exception("Exception: messenger->recvMsg():\n" + traceback.format_exc())
 return msgData
 if __name__ == "__main__":
 test = messenger(None)
 print test.build_message('hello', "This is a test message", attrib1="hello world", attrib2="hello world2", attrib3="hello world3")

Mercurial > traipse

comparison orpg/networking/mplay_messaging.py @ 18:97265586402b ornery-orc