libervia-backend: tools/memory.py comparison

comparison tools/memory.py @ 47:9aa2d9dd4045

memory methods improvement - new method to save private data (mainly useful for plugins) - contacts/presence management refactored - new independant methods to manage subscription

author	Goffi <goffi@goffi.org>
date	Wed, 06 Jan 2010 23:49:55 +1100
parents	d24629c631fc
children	a5b5fb5fc9fd

comparison

equal deleted inserted replaced

-:18f6c9e60507
+:9aa2d9dd4045
 import pickle
 from xml.dom import minidom
 from logging import debug, info, error
 import pdb
 from twisted.internet import defer
+from twisted.words.protocols.jabber import jid
 SAVEFILE_PARAM="/param"
 SAVEFILE_HISTORY="/history"
+SAVEFILE_PRIVATE="/private"  #file used to store misc values (mainly for plugins)
 class Param():
 """This class manage parameter with xml"""
 ### TODO: add desciption in params
 def __init__(self, host):
 debug("Parameters init")
 self.host = host
 host.set_const('savefile_param', SAVEFILE_PARAM)
 host.set_const('savefile_history', SAVEFILE_HISTORY)
+host.set_const('savefile_private', SAVEFILE_PRIVATE)
 host.registerGeneralCB("registerNewAccount", host.registerNewAccountCB)
 def __get_unique_node(self, parent, tag, name):
 """return node with given tag, create a new one if the node doesn't exist
 @param parent: parent of nodes to check (e.g. documentElement)
 """This class manage all persistent informations"""
 def __init__(self, host):
 info ("Memory manager init")
 self.host = host
-self.contact={}
+self.contacts={}
 self.presenceStatus={}
+self.subscriptions={}
 self.params=Param(host)
-self.history={}
+self.history={}  #used to store chat history (key: short jid)
+self.private={}  #used to store private value
 self.disco={}  #XXX: maybe best in a separate class
 self.features={}
 self.load()
 def load(self):
 """Load parameters and all memory things from file/db"""
 param_file = os.path.expanduser(self.host.get_const('local_dir')+
 self.host.get_const('savefile_param'))
 history_file = os.path.expanduser(self.host.get_const('local_dir')+
 self.host.get_const('savefile_history'))
+private_file = os.path.expanduser(self.host.get_const('local_dir')+
+self.host.get_const('savefile_private'))
 #parameters
 if os.path.exists(param_file):
 try:
 self.params.load(param_file)
 self.history=pickle.load(history_pickle)
 debug("history loaded")
 except:
 error ("Can't load history !")
+#private
+if os.path.exists(private_file):
+try:
+with open(private_file, 'r') as private_pickle:
+self.private=pickle.load(private_pickle)
+debug("private values loaded")
+except:
+error ("Can't load private values !")
 def save(self):
 """Save parameters and all memory things to file/db"""
 #TODO: need to encrypt files (at least passwords !) and set permissions
 param_file = os.path.expanduser(self.host.get_const('local_dir')+
 self.host.get_const('savefile_param'))
 history_file = os.path.expanduser(self.host.get_const('local_dir')+
 self.host.get_const('savefile_history'))
+private_file = os.path.expanduser(self.host.get_const('local_dir')+
+self.host.get_const('savefile_private'))
 self.params.save(param_file)
 debug("params saved")
 with open(history_file, 'w') as history_pickle:
 pickle.dump(self.history, history_pickle)
 debug("history saved")
+with open(private_file, 'w') as private_pickle:
+pickle.dump(self.private, private_pickle)
+debug("private values saved")
 def addToHistory(self, me_jid, from_jid, to_jid, type, message):
 me_short=me_jid.userhost()
 from_short=from_jid.userhost()
 to_short=to_jid.userhost()
 for stamp in stamps[-size:]:
 ret[stamp]=self.history[from_jid][to_jid][stamp]
 return ret
-def addContact(self, JID, attributes, groups):
+def setPrivate(self, key, value):
-debug("Memory addContact: %s",JID)
+"""Save a misc private value (mainly useful for plugins)"""
+self.private[key] = value
+def getPrivate(self, key):
+"""return a private value
+@param key: name of wanted value
+@return: value or None if value don't exist"""
+if self.private.has_key(key):
+return self.private[key]
+return None
+def addContact(self, contact_jid, attributes, groups):
+debug("Memory addContact: %s",contact_jid.userhost())
 assert(isinstance(attributes,dict))
 assert(isinstance(groups,set))
-self.contact[JID]=[attributes, groups]
+self.contacts[contact_jid.userhost()]=[attributes, groups]
-def addPresenceStatus(self, jid, type, show, status, priority):
+def delContact(self, contact_jid):
-self.presenceStatus[jid]=[type, show, status, priority]
+debug("Memory delContact: %s",contact_jid.userhost())
+if self.contacts.has_key(contact_jid.userhost()):
+del self.contacts[contact_jid.userhost()]
+def getContact(self, contact_jid):
+if self.contacts.has_key(contact_jid.userhost()):
+self.contacts[contact_jid.userhost()]
+else:
+return None
 def getContacts(self):
-debug ("Memory getContact OK (%s)", self.contact)
+debug ("Memory getContact OK (%s)", self.contacts)
 ret=[]
-for contact in self.contact:
+for contact in self.contacts:
-ret.append([contact] + [self.contact[contact][0]] + [self.contact[contact][1]]) #very ugly I know !
+attr, groups = self.contacts[contact]
+ret.append([contact, attr, groups ])
 return ret
+def addPresenceStatus(self, contact_jid, show, priority, statuses):
+if not self.presenceStatus.has_key(contact_jid.userhost()):
+self.presenceStatus[contact_jid.userhost()] = {}
+resource = jid.parse(contact_jid.full())[2] or ''
+self.presenceStatus[contact_jid.userhost()][resource] = (show, priority, statuses)
+def addWaitingSub(self, type, contact_jid):
+"""Called when a subcription request is received"""
+self.subscriptions[contact_jid] = type
+def delWaitingSub(self, contact_jid):
+"""Called when a subcription request is finished"""
+if self.subscriptions.has_key(contact_jid):
+del self.subscriptions[contact_jid]
+def getWaitingSub(self):
+"""Called to get a list of currently waiting subscription requests"""
+return self.subscriptions
 def getPresenceStatus(self):
-status=[]
+debug ("Memory getPresenceStatus (%s)", self.presenceStatus)
-for contact, contactStatus in self.presenceStatus.items():
+return self.presenceStatus
-status.append([contact]+contactStatus)
-debug ("Memory getPresenceStatus (%s)", status)
-return status
 def getParamA(self, name, category, attr="value"):
 return self.params.getParamA(name, category, attr)
 def getParams(self):

Mercurial > libervia-backend

comparison tools/memory.py @ 47:9aa2d9dd4045