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

comparison src/memory/memory.py @ 722:04aabc3f2684

core (memory): fixed setDefault behaviour + minor refactoring

author	Goffi <goffi@goffi.org>
date	Thu, 28 Nov 2013 17:23:08 +0100
parents	59c9a7ff903d
children	e07afabc4a25

comparison

equal deleted inserted replaced

-:0077912bc9ba
+:04aabc3f2684
 from sat.memory.persistent import PersistentDict
 from sat.core import exceptions
 SAVEFILE_DATABASE = "/sat.db"
 NO_SECURITY_LIMIT = -1
+INDIVIDUAL = "individual"
+GENERAL = "general"
 class Params(object):
 """This class manage parameters with xml"""
 ### TODO: add desciption in params
 import_node(node, child)
 import_node(self.dom.documentElement, src_dom.documentElement)
 def __default_ok(self, value, name, category):
-#FIXME: gof: will not work with individual parameters
+#FIXME: will not work with individual parameters
-self.setParam(name, value, category)  # FIXME: better to set param xml value ???
+self.setParam(name, value, category)
 def __default_ko(self, failure, name, category):
 error(_("Can't determine default value for [%(category)s/%(name)s]: %(reason)s") % {'category': category, 'name': name, 'reason': str(failure.value)})
 def setDefault(self, name, category, callback, errback=None):
 @param category: category of the parameter
 @param callback: must return a string with the value (use deferred if needed)
 @param errback: must manage the error with args failure, name, category
 """
 #TODO: send signal param update if value changed
-node = self.__getParamNode(name, category, '@ALL@')
+#TODO: manage individual paramaters
+debug ("setDefault called for %(category)s/%(name)s" % {"category": category, "name": name})
+node = self._getParamNode(name, category, '@ALL@')
 if not node:
 error(_("Requested param [%(name)s] in category [%(category)s] doesn't exist !") % {'name': name, 'category': category})
 return
 if node[1].getAttribute('default_cb') == 'yes':
-del node[1].attributes['default_cb']
+# del node[1].attributes['default_cb'] # default_cb is not used anymore as a flag to know if we have to set the default value,
-d = defer.maybeDeferred(callback)
+# and we can still use it later e.g. to call a generic setDefault method
-d.addCallback(self.__default_ok, name, category)
+value = self._getParam(category, name, GENERAL)
-d.addErrback(errback or self.__default_ko, name, category)
+if value is None: # no value set by the user: we have the default value
+debug ("Default value to set, using callback")
-def __getAttr(self, node, attr, value):
+d = defer.maybeDeferred(callback)
+d.addCallback(self.__default_ok, name, category)
+d.addErrback(errback or self.__default_ko, name, category)
+def _getAttr(self, node, attr, value):
 """ get attribute value
 @param node: XML param node
 @param attr: name of the attribute to get (e.g.: 'value' or 'type')
 @param value: user defined value"""
 if attr == 'value':
 @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)
+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':
+if node[0] == GENERAL:
-value = self.__getParam(None, category, name, 'general')
+value = self._getParam(category, name, GENERAL)
-return self.__getAttr(node[1], attr, value)
+return self._getAttr(node[1], attr, value)
-assert node[0] == 'individual'
+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)
+value = self._getParam(category, name, profile=profile)
-return self.__getAttr(node[1], attr, value)
+return self._getAttr(node[1], attr, value)
 def asyncGetStringParamA(self, name, category, attr="value", security_limit=NO_SECURITY_LIMIT, profile_key="@NONE@"):
 d = self.asyncGetParamA(name, category, attr, security_limit, profile_key)
 d.addCallback(self.__type_to_string)
 return d
 """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)"""
-node = self.__getParamNode(name, category)
+node = self._getParamNode(name, category)
 if not node:
 error(_("Requested param [%(name)s] in category [%(category)s] doesn't exist !") % {'name': name, 'category': category})
 return None
 if not self.checkSecurityLimit(node[1], security_limit):
 warning(_("Trying to get parameter '%s' in category '%s' without authorization!!!"
 % (name, category)))
 return None
-if node[0] == 'general':
+if node[0] == GENERAL:
-value = self.__getParam(None, category, name, 'general')
+value = self._getParam(category, name, GENERAL)
-return defer.succeed(self.__getAttr(node[1], attr, value))
+return defer.succeed(self._getAttr(node[1], attr, value))
-assert node[0] == 'individual'
+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)
+value = self._getParam(category, name, profile=profile)
-return defer.succeed(self.__getAttr(node[1], attr, value))
+return defer.succeed(self._getAttr(node[1], attr, value))
 except exceptions.ProfileNotInCacheError:
 #We have to ask data to the storage manager
 d = self.storage.getIndParam(category, name, profile)
-return d.addCallback(lambda value: self.__getAttr(node[1], attr, value))
+return d.addCallback(lambda value: self._getAttr(node[1], attr, value))
-def __getParam(self, profile, category, name, _type='individual', cache=None):
+def _getParam(self, category, name, type_=INDIVIDUAL, cache=None, profile="@NONE@"):
 """Return the param, or None if it doesn't exist
-@param profile: the profile name (not profile key, i.e. name and not something like @DEFAULT@)
 @param category: param category
 @param name: param name
-@param _type: "general" or "individual"
+@param type_: GENERAL or INDIVIDUAL
 @param cache: temporary cache, to use when profile is not logged
+@param profile: the profile name (not profile key, i.e. name and not something like @DEFAULT@)
 @return: param value or None if it doesn't exist
 """
-if _type == 'general':
+if type_ == GENERAL:
 if (category, name) in self.params_gen:
 return self.params_gen[(category, name)]
 return None  # This general param has the default value
-assert (_type == 'individual')
+assert (type_ == INDIVIDUAL)
+if profile == "@NONE@":
+raise exceptions.ProfileNotSetError
 if profile in self.params:
 cache = self.params[profile]  # if profile is in main cache, we use it,
 # ignoring the temporary cache
 elif cache is None:  # else we use the temporary cache if it exists, or raise an exception
 raise exceptions.ProfileNotInCacheError
 # init the result document
 prof_xml = minidom.parseString('<params/>')
 cache = {}
 for type_node in self.dom.documentElement.childNodes:
-if type_node.nodeName != 'general' and type_node.nodeName != 'individual':
+if type_node.nodeName != GENERAL and type_node.nodeName != INDIVIDUAL:
 continue
 # we use all params, general and individual
 for cat_node in type_node.childNodes:
 if cat_node.nodeName != 'category':
 continue
 if name not in dest_params:
 # this is reached when a previous category exists
 dest_params[name] = param_node.cloneNode(True)
 dest_cat.appendChild(dest_params[name])
-profile_value = self.__getParam(profile, category,
+profile_value = self._getParam(category,
 name, type_node.nodeName,
-cache=profile_cache)
+cache=profile_cache, profile=profile)
 if profile_value is not 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 "<category />"
 d = self.__constructProfileXml(security_limit, profile)
 return d.addCallback(returnCategoryXml)
-def __getParamNode(self, name, category, _type="@ALL@"):  # FIXME: is _type useful ?
+def _getParamNode(self, name, category, type_="@ALL@"):  # FIXME: is type_ useful ?
 """Return a node from the param_xml
 @param name: name of the node
 @param category: category of the node
-@_type: keyword for search:
+@type_: keyword for search:
 @ALL@ search everywhere
 @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')
+if (((type_ == "@ALL@" or type_ == "@GENERAL@") and type_node.nodeName == GENERAL)
-or ((_type == "@ALL@" or _type == "@INDIVIDUAL@") and type_node.nodeName == 'individual')):
+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:
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_('Trying to set parameter for an unknown profile'))
 return  # TODO: throw an error
-node = self.__getParamNode(name, category, '@ALL@')
+node = self._getParamNode(name, category, '@ALL@')
 if not node:
 error(_('Requesting an unknown parameter (%(category)s/%(name)s)')
 % {'category': category, 'name': name})
 return
 if not self.checkSecurityLimit(node[1], security_limit):
 warning(_("Trying to set parameter '%s' in category '%s' without authorization!!!"
 % (name, category)))
 return
-if node[0] == 'general':
+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)
 self.host.trigger.point("paramUpdateTrigger", name, value, category, node[0], profile)
 return
-assert (node[0] == 'individual')
+assert (node[0] == INDIVIDUAL)
 assert (profile_key != "@NONE@")
-_type = node[1].getAttribute("type")
+type_ = node[1].getAttribute("type")
-if _type == "button":
+if type_ == "button":
 print "clique", node.toxml()
 else:
 if self.host.isConnected(profile):  # key can not exists if profile is not connected
 self.params[profile][(category, name)] = value
 self.host.bridge.paramUpdate(name, value, category, profile)
 def deleteProfile(self, name):
 """Delete an existing profile
 @param name: Name of the profile"""
 return self.params.deleteProfile(name)
-def addToHistory(self, from_jid, to_jid, message, _type='chat', extra=None, timestamp=None, profile="@NONE@"):
+def addToHistory(self, from_jid, to_jid, message, type_='chat', extra=None, timestamp=None, profile="@NONE@"):
 assert profile != "@NONE@"
 if extra is None:
 extra = {}
-return self.storage.addToHistory(from_jid, to_jid, message, _type, extra, timestamp, profile)
+return self.storage.addToHistory(from_jid, to_jid, message, type_, extra, timestamp, profile)
 def getHistory(self, from_jid, to_jid, limit=0, between=True, profile="@NONE@"):
 assert profile != "@NONE@"
 return self.storage.getHistory(jid.JID(from_jid), jid.JID(to_jid), limit, between, profile)
 @param profile: which profile is using this server ?"""
 if profile not in self.server_features:
 self.server_features[profile] = []
 self.server_features[profile].append(feature)
-def addServerIdentity(self, category, _type, entity, profile):
+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:
 self.server_identities[profile] = {}
-if (category, _type) not in self.server_identities[profile]:
+if (category, type_) not in self.server_identities[profile]:
-self.server_identities[profile][(category, _type)] = set()
+self.server_identities[profile][(category, type_)] = set()
-self.server_identities[profile][(category, _type)].add(entity)
+self.server_identities[profile][(category, type_)].add(entity)
-def getServerServiceEntities(self, category, _type, profile):
+def getServerServiceEntities(self, category, type_, profile):
 """Return all available entities for a service"""
 if profile in self.server_identities:
-return self.server_identities[profile].get((category, _type), set())
+return self.server_identities[profile].get((category, type_), set())
 else:
 return None
-def getServerServiceEntity(self, category, _type, profile):
+def getServerServiceEntity(self, category, type_, profile):
 """Helper method to get first available entity for a service"""
-entities = self.getServerServiceEntities(category, _type, profile)
+entities = self.getServerServiceEntities(category, type_, profile)
 if entities is None:
 warning(_("Entities (%(category)s/%(type)s) not available, maybe they haven't been asked to server yet ?") % {"category": category,
-"type": _type})
+"type": type_})
 return None
 else:
 return list(entities)[0] if entities else None
 def hasServerFeature(self, feature, profile_key):
 try:
 del self.entitiesCache[profile][entity_jid.userhost()]
 except KeyError:
 pass
-def addWaitingSub(self, _type, entity_jid, profile_key):
+def addWaitingSub(self, type_, entity_jid, profile_key):
 """Called when a subcription request is received"""
 profile = self.getProfileName(profile_key)
 assert profile
 if profile not in self.subscriptions:
 self.subscriptions[profile] = {}
-self.subscriptions[profile][entity_jid] = _type
+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

Mercurial > libervia-backend

comparison src/memory/memory.py @ 722:04aabc3f2684