libervia-backend: src/memory/memory.py comparison

comparison src/memory/memory.py @ 587:952322b1d490

Remove trailing whitespaces.

author	Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date	Fri, 18 Jan 2013 17:55:34 +0100
parents	89f9a50ce7bf
children	beaf6bec2fcd

comparison

equal deleted inserted replaced

-:6a718ede8be1
+:952322b1d490
 class Params():
 """This class manage parameters with xml"""
 ### TODO: add desciption in params
 #TODO: move Watched in a plugin
 default_xml = u"""
 <params>
 <general>
 </general>
 source_map = getNodesMap(source_node.childNodes)
 dest_map = getNodesMap(dest_node.childNodes)
 source_set = set(source_map.keys())
 dest_set = set(dest_map.keys())
 to_add = source_set.difference(dest_set)
 for node_key in to_add:
 dest_node.appendChild(source_map[node_key].cloneNode(True))
 to_recurse = source_set - to_add
 for node_key in to_recurse:
 def load_xml(self, xml_file):
 """Load parameters template from file"""
 self.dom = minidom.parse(xml_file)
 default_dom = minidom.parseString(Params.default_xml.encode('utf-8'))
 self._mergeParams(default_dom.documentElement, self.dom.documentElement)
 def loadGenParams(self):
 """Load general parameters data from storage
 @return: deferred triggered once params are loaded"""
 return self.storage.loadGenParams(self.params_gen)
 def loadIndParams(self, profile, cache=None):
 """Load individual parameters
 set self.params cache or a temporary cache
 @param profile: profile to load (*must exist*)
 @param cache: if not None, will be used to store the value, as a short time cache
 @return: deferred triggered once params are loaded"""
 if cache == None:
 self.params[profile] = {}
 return self.storage.loadIndParams(self.params[profile] if cache==None else cache, profile)
 def purgeProfile(self, profile):
 """Remove cache data of a profile
 @param profile: %(doc_profile)s"""
 try:
 del self.params[profile]
 """Helper method to get a specific attribute
 @param name: name of the parameter
 @param category: category of the parameter
 @param attr: name of the attribute (default: "value")
 @param profile: owner of the param (@ALL@ for everyone)
 @return: attribute"""
 #FIXME: looks really dirty and buggy, need to be reviewed/refactored
 node = self.__getParamNode(name, category)
 if not node:
 error(_("Requested param [%(name)s] in category [%(category)s] doesn't exist !") % {'name':name, 'category':category})
 raise exceptions.NotFound
 if node[0] == 'general':
 value = self.__getParam(None, category, name, 'general')
 return self.__getAttr(node[1], attr, value)
 assert(node[0] == 'individual')
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_('Requesting a param for an non-existant profile'))
 raise exceptions.ProfileUnknownError
 if profile not in self.params:
 error(_('Requesting synchronous param for not connected profile'))
 raise exceptions.NotConnectedProfileError(profile)
 if attr == "value":
 value = self.__getParam(profile, category, name)
 return self.__getAttr(node[1], attr, value)
 def asyncGetStringParamA(self, name, category, attr="value", profile_key="@DEFAULT@"):
 d = self.asyncGetParamA(name, category, attr, profile_key)
 return None
 if node[0] == 'general':
 value = self.__getParam(None, category, name, 'general')
 return defer.succeed(self.__getAttr(node[1], attr, value))
 assert(node[0] == 'individual')
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_('Requesting a param for a non-existant profile'))
 return defer.fail()
 if attr != "value":
 return defer.succeed(node[1].getAttribute(attr))
 try:
 value = self.__getParam(profile, category, name)
 return defer.succeed(self.__getAttr(node[1], attr, value))
 except exceptions.ProfileNotInCacheError:
 continue
 dest_params[node.getAttribute('name')] = node
 for param_node in params:
 name = param_node.getAttribute('name')
 if name not in dest_params:
 dest_params[name] = param_node.cloneNode(True)
 dest_cat.appendChild(dest_params[name])
 profile_value = self.__getParam(profile, category, name, type_node.nodeName, cache=profile_cache)
 if profile_value!=None:  #there is a value for this profile, we must change the default
 dest_params[name].setAttribute('value', profile_value)
 if new_node:
 prof_xml.documentElement.appendChild(dest_cat)
 return prof_xml
 if self.params.has_key(profile):
 d = defer.succeed(None)
 profile_cache = self.params[profile]
 else:
 #profile is not in cache, we load values in a short time cache
 Take params xml as skeleton"""
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_("Asking params for inexistant profile"))
 return ""
 def returnXML(prof_xml):
 return_xml = prof_xml.toxml()
 prof_xml.unlink()
 return return_xml
 return self.__constructProfileXml(profile).addCallback(returnXML)
 def getParamsForCategory(self, category, profile_key):
 """Return node's xml for selected category"""
 #TODO: manage category of general type (without existant profile)
 profile = self.getProfileName(profile_key)
 prof_xml.unlink()
 return result
 prof_xml.unlink()
 return "<category />"
 d = self.__constructProfileXml(profile)
 return d.addCallback(returnCategoryXml)
 def __getParamNode(self, name, category, _type="@ALL@"): #FIXME: is _type useful ?
 """Return a node from the param_xml
 @GENERAL@ only search in general type
 @INDIVIDUAL@ only search in individual type
 @return: a tuple with the node type and the the node, or None if not found"""
 for type_node in self.dom.documentElement.childNodes:
 if ( ((_type == "@ALL@" or _type == "@GENERAL@") and type_node.nodeName == 'general')
 or ( (_type == "@ALL@" or _type == "@INDIVIDUAL@") and type_node.nodeName == 'individual') ):
 for node in type_node.getElementsByTagName('category'):
 if node.getAttribute("name") == category:
 params = node.getElementsByTagName("param")
 for param in params:
 if param.getAttribute("name") == name:
 return (type_node.nodeName, param)
 return None
 def getParamsCategories(self):
 """return the categories availables"""
 categories=[]
 for cat in self.dom.getElementsByTagName("category"):
 name = cat.getAttribute("name")
 node = self.__getParamNode(name, category, '@ALL@')
 if not node:
 error(_('Requesting an unknown parameter (%(category)s/%(name)s)') % {'category':category, 'name':name})
 return
 if node[0] == 'general':
 self.params_gen[(category, name)] = value
 self.storage.setGenParam(category, name, value)
 for profile in self.storage.getProfilesList():
 if self.host.isConnected(profile):
 self.host.bridge.paramUpdate(name, value, category, profile)
 return
 assert (node[0] == 'individual')
 assert (profile_key != "@NONE@")
 _type = node[1].getAttribute("type")
 if _type=="button":
 print "clique",node.toxml()
 else:
 if self.host.isConnected(profile): #key can not exists if profile is not connected
 class Memory:
 """This class manage all persistent informations"""
 def __init__(self, host):
 info (_("Memory manager init"))
 self.initialized = defer.Deferred()
 self.host = host
 self.entitiesCache={} #XXX: keep presence/last resource/other data in cache
 #     /!\ an entity is not necessarily in roster
 self.subscriptions={}
 self.server_features={} #used to store discovery's informations
 def startProfileSession(self, profile):
 """"Iniatialise session for a profile
 @param profile: %(doc_profile)s"""
 info(_("[%s] Profile session started" % profile))
 self.entitiesCache[profile] = {}
 def purgeProfileSession(self, profile):
 """Delete cache of data of profile
 @param profile: %(doc_profile)s"""
 info(_("[%s] Profile session purge" % profile))
 self.params.purgeProfile(profile)
 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_xml = os.path.expanduser(self.getConfig('','local_dir')+
 self.host.get_const('savefile_param_xml'))
 self.params.save_xml(param_file_xml)
 debug(_("params saved"))
 def getProfilesList(self):
 return self.storage.getProfilesList()
 def createProfile(self, name):
 """Create a new profile
 @param name: Profile name
 """
 return self.params.createProfile(name)
 def asyncCreateProfile(self, name):
 """Create a new profile
 @param name: Profile name
 """
 return self.params.asyncCreateProfile(name)
 def deleteProfile(self, name):
 """Delete an existing profile
 @param name: Name of the profile"""
 return self.params.deleteProfile(name)
 @param feature: string of the feature
 @param profile: which profile is using this server ?"""
 if not self.server_features.has_key(profile):
 self.server_features[profile] = []
 self.server_features[profile].append(feature)
 def addServerIdentity(self, category, _type, entity, profile):
 """Add an identity discovered from server
 @param feature: string of the feature
 @param profile: which profile is using this server ?"""
 if not profile in self.server_identities:
 return ""
 try:
 return self.entitiesCache[profile][entity]["last_resource"]
 except KeyError:
 return ""
 def getPresenceStatus(self, profile_key):
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_('Asking contacts for a non-existant profile'))
 return {}
 @param profile_key: %(doc_profile_key)s
 @return: dict withs values for each key in keys_list.
 if there is no value of a given key, resulting dict will
 have nothing with that key nether
 @raise: exceptions.UnknownEntityError if entity is not in cache
 exceptions.ProfileNotInCacheError if profile is not in cache
 """
 profile = self.getProfileName(profile_key)
 if not profile:
 raise exceptions.UnknownProfileError(_('Trying to get entity data for a non-existant profile'))
 if not profile in self.entitiesCache:
 profile = self.getProfileName(profile_key)
 assert(profile)
 if not self.subscriptions.has_key(profile):
 self.subscriptions[profile] = {}
 self.subscriptions[profile][entity_jid] = _type
 def delWaitingSub(self, entity_jid, profile_key):
 """Called when a subcription request is finished"""
 profile = self.getProfileName(profile_key)
 assert(profile)
 if self.subscriptions.has_key(profile) and self.subscriptions[profile].has_key(entity_jid):
 del self.subscriptions[profile][entity_jid]
 def getWaitingSub(self, profile_key):
 """Called to get a list of currently waiting subscription requests"""
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_('Asking waiting subscriptions for a non-existant profile'))
 return {}
 if not self.subscriptions.has_key(profile):
 return {}
 return self.subscriptions[profile]
 def getStringParamA(self, name, category, attr="value", profile_key='@DEFAULT@'):
 return self.params.getStringParamA(name, category, attr, profile_key)
 def getParamA(self, name, category, attr="value", profile_key='@DEFAULT@'):
 return self.params.getParamA(name, category, attr, profile_key)
 def asyncGetParamA(self, name, category, attr="value", profile_key='@DEFAULT@'):
 return self.params.asyncGetParamA(name, category, attr, profile_key)
 def asyncGetStringParamA(self, name, category, attr="value", profile_key='@DEFAULT@'):
 return self.params.asyncGetStringParamA(name, category, attr, profile_key)
 def getParamsUI(self, profile_key):
 return self.params.getParamsUI(profile_key)
 def getParams(self, profile_key):
 return self.params.getParams(profile_key)
 def getParamsForCategory(self, category, profile_key):
 return self.params.getParamsForCategory(category, profile_key)
 def getParamsCategories(self):
 return self.params.getParamsCategories()
 def setParam(self, name, value, category, profile_key):
 return self.params.setParam(name, value, category, profile_key)
 def importParams(self, xml):
 return self.params.importParams(xml)
 def setDefault(self, name, category, callback, errback=None):
 return self.params.setDefault(name, category, callback, errback)

Mercurial > libervia-backend

comparison src/memory/memory.py @ 587:952322b1d490