traipse_dev: orpg/networking/meta_server

comparison orpg/networking/meta_server_lib.py @ 71:449a8900f9ac ornery-dev

Code refining almost completed, for this round. Some included files are still in need of some clean up, but this is test worthy.

author	sirebral
date	Thu, 20 Aug 2009 03:00:39 -0500
parents	c54768cffbd4
children	d1aff41c031b

comparison

equal deleted inserted replaced

-:52a5fa913008
+:449a8900f9ac
 META_DEBUG = 0
 __version__ = "$Id: meta_server_lib.py,v 1.40 2007/04/04 01:18:42 digitalxero Exp $"
 from orpg.orpg_version import PROTOCOL_VERSION
-from orpg.orpgCore import *
+from orpg.orpgCore import component
+from orpg.tools.validate import validate
 from orpg.dirpath import dir_struct
 import urllib
 import orpg.minidom
 from threading import *
 import time
 file.close()
 # Remove any leading or trailing data.  This can happen on some satellite connections
 p = re.compile('(<servers>.*?</servers>)',re.DOTALL|re.IGNORECASE)
 mo = p.search(data)
-if mo:
+if mo: data = mo.group(0)
-data = mo.group(0)
 if META_DEBUG:
 print
 print "Got this string from the Meta at " + path + ":"
 print "==============================================="
 xml_dom = xml.parseXml(data)
 xml_dom = xml_dom._get_documentElement()
 return xml_dom
 def post_server_data( name, realHostName=None):
-# build POST data
-##    data = urllib.urlencode( {"server_data[name]":name,
-##                              "server_data[version]":PROTOCOL_VERSION,
-##                              "act":"new"} )
-##
 if realHostName:
 data = urllib.urlencode( {"server_data[name]":name,
 "server_data[version]":PROTOCOL_VERSION,
 "act":"new",
 "REMOTE_ADDR": realHostName } )
 #print "Letting meta server decide the hostname to list..."
 data = urllib.urlencode( {"server_data[name]":name,
 "server_data[version]":PROTOCOL_VERSION,
 "act":"new"} )
-xml_dom = get_server_dom( data , "http://openrpg.sf.net/openrpg_servers.php")
+#xml_dom = get_server_dom( data , "http://openrpg.sf.net/openrpg_servers.php")#Sourceforge still?
+path = component.get('settings').get_setting('MetaServerBaseURL') #getMetaServerBaseURL()
+xml_dom = get_server_dom(data, path)
 ret_val = int( xml_dom.getAttribute( "id" ) )
 return ret_val
 def post_failed_connection(id,meta=None,address=None,port=None):
 #  For now, turning this off.  This needs to be re-vamped for
 #  handling multiple Metas.
 return 0
-#    data = urllib.urlencode({"id":id,"act":"failed"});
+#data = urllib.urlencode({"id":id,"act":"failed"});
-#    xml_dom = get_server_dom(data)
+#xml_dom = get_server_dom(data)
-#    ret_val = int(xml_dom.getAttribute("return"))
+#ret_val = int(xml_dom.getAttribute("return"))
-#    return ret_val
+#return ret_val
 def remove_server(id):
 data = urllib.urlencode({"id":id,"act":"del"});
 xml_dom = get_server_dom(data)
 ret_val = int(xml_dom.getAttribute("return"))
 def byStartAttribute(first,second):
 #  This function is used to easily sort a list of nodes
 #  by their start time
-if first.hasAttribute("start"):
+if first.hasAttribute("start"): first_start = int(first.getAttribute("start"))
-first_start = int(first.getAttribute("start"))
+else: first_start = 0
-else:
-first_start = 0
+if second.hasAttribute("start"): second_start = int(second.getAttribute("start"))
+else: second_start = 0
-if second.hasAttribute("start"):
-second_start = int(second.getAttribute("start"))
-else:
-second_start = 0
 # Return the result of the cmp function on the two strings
 return cmp(first_start,second_start)
 def byNameAttribute(first,second):
 #  This function is used to easily sort a list of nodes
 #  by their name attribute
 # Ensure there is something to sort with for each
-if first.hasAttribute("name"):
+if first.hasAttribute("name"): first_name = str(first.getAttribute("name")).lower()
-first_name = str(first.getAttribute("name")).lower()
+else: first_name = ""
-else:
-first_name = ""
+if second.hasAttribute("name"): second_name = str(second.getAttribute("name")).lower()
+else: second_name = ""
-if second.hasAttribute("name"):
-second_name = str(second.getAttribute("name")).lower()
-else:
-second_name = ""
 # Return the result of the cmp function on the two strings
 return cmp(first_name,second_name)
 def get_server_list(versions = None,sort_by="start"):
 data = urllib.urlencode({"version":PROTOCOL_VERSION,"ports":"%"})
 return_hash = {}  # this will end up with an amalgamated list of servers
 for meta in all_metas:                  # check all of the metas
-#  get the server's xml from the current meta
+#get the server's xml from the current meta
 bad_meta = 0
 #print "Getting server list from " + meta + "..."
-try:
+try: xml_dom = get_server_dom(data=data,path=meta)
-xml_dom = get_server_dom(data=data,path=meta)
 except:
 #print "Trouble getting servers from " + meta + "..."
 bad_meta = 1
 if bad_meta:
 return_list = return_hash.values()
 #  sort them by their name attribute.  Uses byNameAttribute()
 #  defined above as a comparison function
-if sort_by == "start":
+if sort_by == "start": return_list.sort(byStartAttribute)
-return_list.sort(byStartAttribute)
+elif sort_by == "name": return_list.sort(byNameAttribute)
-elif sort_by == "name":
-return_list.sort(byNameAttribute)
 #  Add each node to the DOM
-for n in return_list:
+for n in return_list: return_dom.appendChild(n)
-return_dom.appendChild(n)
 return return_dom
 ## List Format:
 ## <servers>
 ## <server address=? id=? name=? failed_count=? >
 def getRawMetaList():
 try:
 try:
 metacache_lock.acquire()
 #  Read in the metas
-component.get('validate').config_file("metaservers.cache","metaservers.cache")
+validate.config_file("metaservers.cache","metaservers.cache")
 ini = open(dir_struct["user"]+"metaservers.cache","r")
 metas = ini.readlines()
 ini.close()
 return metas
 finally:
 if META_DEBUG: traceback.print_exc()
 print "Meta Server Lib: getRawMetaList(): " + str(e)
 return []
 def getMetaServers(versions = None, pick_random=0):
-# get meta server URLs as a list
+"""
+get meta server URLs as a list
-#  versions is a list of acceptable version numbers.
-#    A False truth value will use getMetaServerBaseURL()
+versions is a list of acceptable version numbers.
+A False truth value will use getMetaServerBaseURL()
-# set a default if we have weird reading problems
-# default_url = "http://www.openrpg.com/openrpg_servers.php"
+set a default if we have weird reading problems
+default_url = "http://www.openrpg.com/openrpg_servers.php"
+"""
 meta_names = []
 if(versions):  #  If versions are supplied, then look in metaservers.conf
 try:
-#  read in the metas from file
+"""
-#  format of file is one meta entry per line
+read in the metas from file
-#  each entry will be the meta url, followed by one or more version numbers that it
+format of file is one meta entry per line
-#  handle.  Generally, this will be either a 1 for the original Meta format, or
+each entry will be the meta url, followed by one or more version numbers that it
-#  2 for the new one.
+handle.  Generally, this will be either a 1 for the original Meta format, or
+2 for the new one.
+"""
 #  Read in the metas
 metas = getRawMetaList()
 #print str(metas)
 for meta in metas:
 # split the line on whitespace
 #   obviously, your meta servers urls shouldn't contain whitespace.  duh.
 words = meta.split()
 success = 0         #  init success flag for version check
 for version in versions:    # run through each allowed version from caller
 if version in words[1:]:  #  if the allowed version token was found
 success += 1          #  then increment the success indicator
 if success:          #  if the meta entry is acceptable to the caller
 meta_names.append(words[0])    #  add the entry
 if META_DEBUG: print "adding metaserver " + meta
 #  at this point, we should have at least one name from the cache.  If not ...
 if not meta_names:
 default_meta = getMetaServerBaseURL()       # grab the meta from ini.xml
 meta_names.append(default_meta)             # add it to the return list
-#                print "Warning!!\nNo valid metaservers cached."
+# print "Warning!!\nNo valid metaservers cached."
-#                print "Using meta from MetaServerBaseURL: " + default_meta + "\n"
+# print "Using meta from MetaServerBaseURL: " + default_meta + "\n"
 # if we have more than one and want a random one
 elif pick_random:
 if META_DEBUG: print "choosing random meta from: " + str(meta_names)
 i = int(random.uniform(0,len(meta_names)))
 #meta = meta_names[i]
 node_list = tree.getElementsByTagName("MetaServerBaseURL")
 if node_list:
 url = node_list[0].getAttribute("value")
 # allow tree to be collected
-try:
+try: tree.unlink()
-tree.unlink()
+except: pass
-except:
-pass
 except Exception,e:
 print e
-#    print "using meta server URI: " + url
+#print "using meta server URI: " + url
 return url
-#######################################################################################
+"""
-#  Beginning of Class registerThread
+Beginning of Class registerThread
-#
-#  A Class to Manage Registration with the Meta2
+A Class to Manage Registration with the Meta2
-#  Create an instance and call it's start() method
+Create an instance and call it's start() method
-#  if you want to be (and stay) registered.  This class
+if you want to be (and stay) registered.  This class
-#  will take care of registering and re-registering as
+will take care of registering and re-registering as
-#  often as necessary to stay in the Meta list.
+often as necessary to stay in the Meta list.
-#
-#  You may call register() yourself if you wish to change your
+You may call register() yourself if you wish to change your
-#  server's name.  It will immediately update the Meta.  There
+server's name.  It will immediately update the Meta.  There
-#  is no need to unregister first.
+is no need to unregister first.
-#
-#  Call unregister() when you no longer want to be registered.
+Call unregister() when you no longer want to be registered.
-#  This will result in the registerThread dying after
+This will result in the registerThread dying after
-#  attempting to immediately remove itself from the Meta.
+attempting to immediately remove itself from the Meta.
-#
-#  If you need to become registered again after that, you
+If you need to become registered again after that, you
-#  must create a new instance of class registerThread.  Don't
+must create a new instance of class registerThread.  Don't
-#  just try to call register() on the old, dead thread class.
+just try to call register() on the old, dead thread class.
+"""
 class registerThread(Thread):
-#  Originally, I wrote this as a sub-class of wxThread, but
+"""
-#       A)  I couldn't get it to import right
+Originally, I wrote this as a sub-class of wxThread, but
-#       B)  I realized that I want this to be used in a server,
+A)  I couldn't get it to import right
-#           which I don't want needing wxWindows to run!
+B)  I realized that I want this to be used in a server,
-#
+which I don't want needing wxWindows to run!
-#   Because of this fact, there are some methods from wxThread
-#   that I implemented to minimize changes to the code I had
+Because of this fact, there are some methods from wxThread
-#   just written, i.e. TestDeleteStatus() and Delete()
+that I implemented to minimize changes to the code I had
+just written, i.e. TestDeleteStatus() and Delete()
+"""
 def __init__(self,name=None,realHostName=None,num_users = "Hmmm",MetaPath=None,port=6774,register_callback=None):
 Thread.__init__(self,name="registerThread")
 self.rlock = RLock()                    #  Re-entrant lock used to make this class thread safe
 #  indicates a new registration.
 self.interval = 0                       #  interval returned from Meta.  Is how often to
 #  re-register, in minutes.
 self.destroy = 0                        #  Used to flag that this thread should die
 self.port = str(port)
-self.register_callback = register_callback               # set a method to call to report result of register
+self.register_callback = register_callback  # set a method to call to report result of register
-#  This thread will communicate with one and only one
+"""
-#  Meta.  If the Meta in ini.xml is changed after
+This thread will communicate with one and only one
-#  instantiation, then this instance must be
+Meta.  If the Meta in ini.xml is changed after
-#  unregistered and a new instance instantiated.
+instantiation, then this instance must be
-#
+unregistered and a new instance instantiated.
-#  Also, if MetaPath is specified, then use that.  Makes
-#  it easier to have multiple registerThreads going to keep the server registered
+Also, if MetaPath is specified, then use that.  Makes
-#  on multiple (compatible) Metas.
+it easier to have multiple registerThreads going to keep the server registered
+on multiple (compatible) Metas.
+"""
 if MetaPath == None:
 self.path = getMetaServerBaseURL()  #  Do this if no Meta specified
 else:
 self.path = MetaPath
 self.die_event.set()
 finally:
 self.rlock.release()
 def run(self):
-#  This method gets called by Thread implementation
+"""
-#  when self.start() is called to begin the thread's
+This method gets called by Thread implementation
-#  execution
+when self.start() is called to begin the thread's
-#
+execution
-#  We will basically enter a loop that continually
-#  re-registers this server and sleeps Interval
+We will basically enter a loop that continually
-#  minutes until the thread is ordered to die in place
+re-registers this server and sleeps Interval
+minutes until the thread is ordered to die in place
+"""
 while(not self.TestDeleteStatus()):         # Loop while until told to die
 #  Otherwise, call thread safe register().
 self.register(self.name, self.realHostName, self.num_users)
 if META_DEBUG: print "Sent Registration Data"
 #  register() will end up setting the state variables
 #  for us, including self.interval.
 try:
 self.rlock.acquire()            #  Serialize access to this state information
 #  If we get past the while loop, it's because we've been asked to die,
 #  so just let run() end.  Once this occurs, the thread is dead and
 #  calls to Thread.isAlive() return False.
 def unregister(self):
-#  This method can (I hope) be called from both within the thread
+"""
-#  and from other threads.  It will attempt to unregister this
+This method can (I hope) be called from both within the thread
-#  server from the Meta database
+and from other threads.  It will attempt to unregister this
-#  When this is either accomplished or has been tried hard enough
+server from the Meta database
-#  (after which it just makes sense to let the Meta remove the
+When this is either accomplished or has been tried hard enough
-#  entry itself when we don't re-register using this id),
+(after which it just makes sense to let the Meta remove the
-#  this method will either cause the thread to immediately die
+entry itself when we don't re-register using this id),
-#  (if called from this thread's context) or set the Destroy flag
+this method will either cause the thread to immediately die
-#  (if called from the main thread), a positive test for which will cause
+(if called from this thread's context) or set the Destroy flag
-#  the code in Entry() to exit() when the thread wakes up and
+(if called from the main thread), a positive test for which will cause
-#  checks TestDeleteStatus().
+the code in Entry() to exit() when the thread wakes up and
-#  lock the critical section.  The unlock will
+checks TestDeleteStatus().
-#  automatically occur at the end of the function in the finally clause
+lock the critical section.  The unlock will
+automatically occur at the end of the function in the finally clause
+"""
 try:
 self.rlock.acquire()
 if not self.isAlive():      #  check to see if this thread is dead
 return 1                #  If so, return an error result
 #  Do the actual unregistering here
 #  No special handling is required.  If the de-registration worked we're done.  If
 #  not, then it's because we've already been removed or have a bad cookie.  Either
 #  way, we can't do anything else, so die.
 self.Delete()            #  This will cause the registerThread to die in register()
 #  prep xml_dom for garbage collection
-try:
+try: xml_dom.unlink()
-xml_dom.unlink()
+except: pass
-except:
-pass
 return 0
-finally:
+finally: self.rlock.release()
-self.rlock.release()
 def register(self, name=None, realHostName=None, num_users=None):
-#  Designed to handle the registration, both new and
+"""
-#  repeated.
+Designed to handle the registration, both new and
-#
+repeated.
-#  It is intended to be called once every interval
-#    (or interval - delta) minutes.
+It is intended to be called once every interval
+(or interval - delta) minutes.
-#  lock the critical section.  The unlock will
-#  automatically occur at the end of the function in the finally clause
+lock the critical section.  The unlock will
+automatically occur at the end of the function in the finally clause
+"""
 try:
 self.rlock.acquire()
 if not self.isAlive():      #  check to see if this thread is dead
 return 1                #  If so, return an error result
 #  Set the server's attibutes, if specified.
-if name:
+if name: self.name = name
-self.name = name
+if num_users != None: self.num_users = num_users
-if num_users != None:
+if realHostName: self.realHostName = realHostName
-self.num_users = num_users
-if realHostName:
-self.realHostName = realHostName
 # build POST data
 if self.realHostName:
 data = urllib.urlencode( {"server_data[id]":self.id,
 "server_data[cookie]":self.cookie,
 "server_data[name]":self.name,
 except:
 if META_DEBUG: print "Problem talking to server.  Setting interval for retry ..."
 if META_DEBUG: print data
 if META_DEBUG: print
 self.interval = 0
-#  If we are in the registerThread thread, then setting interval to 0
+"""
-#  will end up causing a retry in about 6 seconds (see self.run())
+If we are in the registerThread thread, then setting interval to 0
-#  If we are in the main thread, then setting interval to 0 will do one
+will end up causing a retry in about 6 seconds (see self.run())
-#  of two things:
+If we are in the main thread, then setting interval to 0 will do one
-#  1)  Do the same as if we were in the registerThread
+of two things:
-#  2)  Cause the next, normally scheduled register() call to use the values
+1)  Do the same as if we were in the registerThread
-#      provided in this call.
+2)  Cause the next, normally scheduled register() call to use the values
-#
+provided in this call.
-#  Which case occurs depends on where the registerThread thread is when
-#  the main thread calls register().
+Which case occurs depends on where the registerThread thread is when
+the main thread calls register().
+"""
 return 0  # indicates that it was okay to call, not that no errors occurred
 #  If there is a DOM returned ....
 if xml_dom:
 #  If there's an error, echo it to the console
 if xml_dom.hasAttribute("errmsg"):
 print "Error durring registration:  " + xml_dom.getAttribute("errmsg")
 if META_DEBUG: print data
 if META_DEBUG: print
-#  No special handling is required.  If the registration worked, id, cookie, and interval
+"""
-#  can be stored and used for the next time.
+No special handling is required.  If the registration worked, id, cookie, and interval
-#  If an error occurred, then the Meta will delete us and we need to re-register as
+can be stored and used for the next time.
-#  a new server.  The way to indicate this is with a "0" id and "0" cookie sent to
+If an error occurred, then the Meta will delete us and we need to re-register as
-#  the server during the next registration.  Since that's what the server returns to
+a new server.  The way to indicate this is with a "0" id and "0" cookie sent to
-#  us on an error anyway, we just store them and the next registration will
+the server during the next registration.  Since that's what the server returns to
-#  automatically be set up as a new one.
+us on an error anyway, we just store them and the next registration will
-#
+automatically be set up as a new one.
-#  Unless the server calls register() itself in the meantime.  Of course, that's okay
-#  too, because a success on THAT register() call will set up the next one to use
+Unless the server calls register() itself in the meantime.  Of course, that's okay
-#  the issued id and cookie.
+too, because a success on THAT register() call will set up the next one to use
-#
+the issued id and cookie.
-#  The interval is stored unconditionally for similar reasons.  If there's an error,
-#  the interval will be less than 1, and the main thread's while loop will reset it
+The interval is stored unconditionally for similar reasons.  If there's an error,
-#  to 6 seconds for the next retry.
+the interval will be less than 1, and the main thread's while loop will reset it
-#  Is it wrong to have a method where there's more comments than code?  :)
+to 6 seconds for the next retry.
+Is it wrong to have a method where there's more comments than code?  :)
+"""
 try:
 self.interval = int(xml_dom.getAttribute("interval"))
 self.id = xml_dom.getAttribute("id")
 self.cookie = xml_dom.getAttribute("cookie")
 if not xml_dom.hasAttribute("errmsg"):

Mercurial > traipse_dev

comparison orpg/networking/meta_server_lib.py @ 71:449a8900f9ac ornery-dev