erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

core (memory): fixed setDefault behaviour + minor refactoring

Browse source
This commit is contained in:
Goffi 2013-11-28 17:23:08 +01:00
commit 72fa3c5c70
1 changed files with 64 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

116
src/memory/memory.py
View file

@ -34,6 +34,8 @@ from sat.core import exceptions
SAVEFILE_DATABASE = "/sat.db"
NO_SECURITY_LIMIT = -1
INDIVIDUAL = "individual"
GENERAL = "general"
class Params(object):
@ -239,8 +241,8 @@ class Params(object):
import_node(self.dom.documentElement, src_dom.documentElement)
def __default_ok(self, value, name, category):
#FIXME: gof: will not work with individual parameters
self.setParam(name, value, category) # FIXME: better to set param xml value ???
#FIXME: will not work with individual parameters
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)})
@ -254,17 +256,23 @@ class Params(object):
@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']
d = defer.maybeDeferred(callback)
d.addCallback(self.__default_ok, name, category)
d.addErrback(errback or self.__default_ko, name, category)
# 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,
# and we can still use it later e.g. to call a generic setDefault method
value = self._getParam(category, name, GENERAL)
if value is None: # no value set by the user: we have the default value
debug ("Default value to set, using callback")
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):
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')
@ -295,16 +303,16 @@ class Params(object):
@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':
value = self.__getParam(None, category, name, 'general')
return self.__getAttr(node[1], attr, value)
if node[0] == GENERAL:
value = self._getParam(category, name, GENERAL)
return self._getAttr(node[1], attr, value)
assert node[0] == 'individual'
assert node[0] == INDIVIDUAL
profile = self.getProfileName(profile_key)
if not profile:
@ -316,8 +324,8 @@ class Params(object):
raise exceptions.NotConnectedProfileError(profile)
if attr == "value":
value = self.__getParam(profile, category, name)
return self.__getAttr(node[1], attr, value)
value = self._getParam(category, name, profile=profile)
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)
@ -330,7 +338,7 @@ class Params(object):
@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
@ -340,11 +348,11 @@ class Params(object):
% (name, category)))
return None
if node[0] == 'general':
value = self.__getParam(None, category, name, 'general')
return defer.succeed(self.__getAttr(node[1], attr, value))
if node[0] == GENERAL:
value = self._getParam(category, name, GENERAL)
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:
@ -354,27 +362,29 @@ class Params(object):
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))
value = self._getParam(category, name, profile=profile)
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
@ -400,7 +410,7 @@ class Params(object):
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:
@ -436,9 +446,9 @@ class Params(object):
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)
@ -509,19 +519,19 @@ class Params(object):
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')
or ((_type == "@ALL@" or _type == "@INDIVIDUAL@") and type_node.nodeName == 'individual')):
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")
@ -548,7 +558,7 @@ class Params(object):
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})
@ -559,7 +569,7 @@ class Params(object):
% (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():
@ -568,11 +578,11 @@ class Params(object):
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")
if _type == "button":
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
@ -724,11 +734,11 @@ class Memory(object):
@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@"
@ -742,29 +752,29 @@ class Memory(object):
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]:
self.server_identities[profile][(category, _type)] = set()
self.server_identities[profile][(category, _type)].add(entity)
if (category, type_) not in self.server_identities[profile]:
self.server_identities[profile][(category, type_)] = set()
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
@ -887,13 +897,13 @@ class Memory(object):
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"""