Mercurial > libervia-backend
changeset 433:75aa709c83d5
core: memory.py and sqlite.py moved from tools to memory
| author | Goffi <goffi@goffi.org> |
|---|---|
| date | Sun, 20 Nov 2011 15:36:02 +0100 |
| parents | 31e8c48b5f5d |
| children | d7e5df876a04 |
| files | src/tools/memory.py src/tools/sqlite.py |
| diffstat | 2 files changed, 0 insertions(+), 1047 deletions(-) [+] |
line wrap: on
line diff
--- a/src/tools/memory.py Sun Nov 20 15:34:37 2011 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,823 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -""" -SAT: a jabber client -Copyright (C) 2009, 2010, 2011 Jérôme Poisson (goffi@goffi.org) - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see <http://www.gnu.org/licenses/>. -""" - -from __future__ import with_statement - -import os.path -import time -import cPickle as pickle -from ConfigParser import SafeConfigParser, NoOptionError, NoSectionError -from xml.dom import minidom -from logging import debug, info, warning, error -from twisted.internet import defer -from twisted.words.protocols.jabber import jid -from sat.tools.xml_tools import paramsXml2xmlUI -from sat.core.default_config import default_config -from sat.tools.sqlite import SqliteStorage - -SAVEFILE_PARAM_XML="/param" #xml parameters template -SAVEFILE_PRIVATE="/private" #file used to store misc values (mainly for plugins) -SAVEFILE_DATABASE="/sat.db" - -class ProfileNotInCacheError(Exception): - pass - -class ConnectedProfileError(Exception): - pass - -class Param(): - """This class manage parameters with xml""" - ### TODO: add desciption in params - - #TODO: move Watched in a plugin - default_xml = u""" - <params> - <general> - </general> - <individual> - <category name="Connection" label="%(category_connection)s"> - <param name="JabberID" value="name@example.org/SàT" type="string" /> - <param name="Password" value="" type="password" /> - <param name="Server" value="example.org" type="string" /> - <param name="NewAccount" value="%(label_NewAccount)s" type="button" callback_id="registerNewAccount"/> - <param name="autoconnect" label="%(label_autoconnect)s" value="true" type="bool" /> - <param name="autodisconnect" label="%(label_autodisconnect)s" value="false" type="bool" /> - </category> - <category name="Misc" label="%(category_misc)s"> - <param name="Watched" value="test@Jabber.goffi.int" type="string" /> - </category> - </individual> - </params> - """ % {'category_connection': _("Connection"), - 'label_NewAccount': _("Register new account"), - 'label_autoconnect': _('Connect on frontend startup'), - 'label_autodisconnect': _('Disconnect on frontend closure'), - 'category_misc': _("Misc") - } - - def load_default_params(self): - self.dom = minidom.parseString(Param.default_xml.encode('utf-8')) - - def load_xml(self, file): - """Load parameters template from file""" - self.dom = minidom.parse(file) - - 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] - except KeyError: - error(_("Trying to purge cache of a profile not in memory: [%s]") % profile) - - def save_xml(self, file): - """Save parameters template to xml file""" - with open(file, 'wb') as xml_file: - xml_file.write(self.dom.toxml('utf-8')) - - def __init__(self, host, storage): - debug("Parameters init") - self.host = host - self.storage = storage - self.default_profile = None - self.params = {} - self.params_gen = {} - host.set_const('savefile_param_xml', SAVEFILE_PARAM_XML) - host.registerGeneralCB("registerNewAccount", host.registerNewAccountCB) - - def createProfile(self, profile): - """Create a new profile - @param profile: profile of the profile""" - #FIXME: must be asynchronous and call the callback once the profile actually exists - if self.storage.hasProfile(profile): - info (_('The profile profile already exists')) - return True - if not self.host.trigger.point("ProfileCreation", profile): - return False - self.storage.createProfile(profile) - return False - - def asyncCreateProfile(self, profile): - """Create a new profile - @param profile: name of the profile - @param callback: called when the profile actually exists in database and memory - @param errback: called with a string constant as parameter: - - CONFLICT: the profile already exists - - CANCELED: profile creation canceled - """ - if self.storage.hasProfile(profile): - info (_('The profile name already exists')) - return defer.fail("CONFLICT") - if not self.host.trigger.point("ProfileCreation", profile): - return defer.fail("CANCEL") - return self.storage.createProfile(profile) - - - def deleteProfile(self, profile): - """Delete an existing profile - @param profile: name of the profile""" - #TODO: async equivalent, like for createProfile - if not self.storage.hasProfile(profile): - error(_('Trying to delete an unknown profile')) - return True - if self.host.isConnected(profile): - error(_("Trying to delete a connected profile")) - raise ConnectedProfileError - self.storage.deleteProfile(profile) - return False - - def getProfileName(self, profile_key): - """return profile according to profile_key - @param profile_key: profile name or key which can be - @ALL@ for all profiles - @DEFAULT@ for default profile - @return: requested profile name or None if it doesn't exist""" - if profile_key=='@DEFAULT@': - if not self.params: - return "" - default = self.host.memory.getPrivate('Profile_default') - if not default or not default in self.params: - info(_('No default profile, returning first one')) #TODO: manage real default profile - default = self.storage.getProfilesList()[0] - self.host.memory.setPrivate('Profile_default', default) - return default #FIXME: temporary, must use real default value, and fallback to first one if it doesn't exists - if not self.storage.hasProfile(profile_key): - info (_('Trying to access an unknown profile')) - return "" - return profile_key - - def __get_unique_node(self, parent, tag, name): - """return node with given tag - @param parent: parent of nodes to check (e.g. documentElement) - @param tag: tag to check (e.g. "category") - @param name: name to check (e.g. "JID") - @return: node if it exist or None - """ - for node in parent.childNodes: - if node.nodeName == tag and node.getAttribute("name") == name: - #the node already exists - return node - #the node is new - return None - - def importParams(self, xml): - """import xml in parameters, do nothing if the param already exist - @param xml: parameters in xml form""" - src_dom = minidom.parseString(xml.encode('utf-8')) - - def import_node(tgt_parent, src_parent): - for child in src_parent.childNodes: - if child.nodeName == '#text': - continue - node = self.__get_unique_node(tgt_parent, child.nodeName, child.getAttribute("name")) - if not node: #The node is new - tgt_parent.appendChild(child) - else: - 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 - self.setParam(name, value, category) #FIXME: better to set param xml value ??? - - 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): - """Set default value of parameter - 'default_cb' attibute of parameter must be set to 'yes' - @param name: name of the parameter - @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@') - 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) - - def getParamA(self, name, category, attr="value", profile_key="@DEFAULT@"): - """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""" - 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 "" - - if node[0] == 'general': - value = self.__getParam(None, category, name, 'general') - return value if value!=None else node[1].getAttribute(attr) - - assert(node[0] == 'individual') - - profile = self.getProfileName(profile_key) - if not profile: - error(_('Requesting a param for an non-existant profile')) - return "" - - if profile not in self.params: - error(_('Requesting synchronous param for not connected profile')) - return "" - - if attr == "value": - value = self.__getParam(profile, category, name) - return value if value!=None else node[1].getAttribute(attr) - else: - return node[1].getAttribute(attr) - - def asyncGetParamA(self, name, category, attr="value", profile_key="@DEFAULT@"): - """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) - if not node: - error(_("Requested param [%(name)s] in category [%(category)s] doesn't exist !") % {'name':name, 'category':category}) - return None - - if node[0] == 'general': - value = self.__getParam(None, category, name, 'general') - return defer.succeed(value if value!=None else node[1].getAttribute(attr)) - - 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)) - default = node[1].getAttribute(attr) - try: - value = self.__getParam(profile, category, name) - return defer.succeed(value if value!=None else default) - except ProfileNotInCacheError: - #We have to ask data to the storage manager - d = self.storage.getIndParam(category, name, profile) - return d.addCallback(lambda value: value if value!=None else default) - - def __getParam(self, profile, category, name, type='individual', cache=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 cache: temporary cache, to use when profile is not logged - @return: param value or None if it doesn't exist - """ - if type == 'general': - if self.params_gen.has_key((category, name)): - return self.params_gen[(category, name)] - return None #This general param has the default value - assert (type == 'individual') - if self.params.has_key(profile): - cache = self.params[profile] # if profile is in main cache, we use it, - # ignoring the temporary cache - elif cache == None: #else we use the temporary cache if it exists, or raise an exception - raise ProfileNotInCacheError - if not cache.has_key((category, name)): - return None - return cache[(category, name)] - - def __constructProfileXml(self, profile): - """Construct xml for asked profile, filling values when needed - /!\ as noticed in doc, don't forget to unlink the minidom.Document - @param profile: profile name (not key !) - @return: a deferred that fire a minidom.Document of the profile xml (cf warning above) - """ - def constructProfile(ignore,profile_cache): - prof_xml = minidom.parseString('<params/>') - cache = {} - - for type_node in self.dom.documentElement.childNodes: - if type_node.nodeName == 'general' or type_node.nodeName == 'individual': #we use all params, general and individual - for cat_node in type_node.childNodes: - if cat_node.nodeName == 'category': - category = cat_node.getAttribute('name') - if not cache.has_key(category): - cache[category] = dest_cat = cat_node.cloneNode(True) #we make a copy for the new xml - new_node = True - else: - dest_cat = cache[category] - new_node = False #It's not a new node, we will merge information - params = cat_node.getElementsByTagName("param") - dest_params = {} - for node in dest_cat.childNodes: - if node.nodeName != "param": - 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 - profile_cache = {} - d = self.loadIndParams(profile, profile_cache) - - return d.addCallback(constructProfile, profile_cache) - - def getParamsUI(self, profile_key): - """Return a SàT XMLUI for parameters, with given profile""" - profile = self.getProfileName(profile_key) - if not profile: - error(_("Asking params for inexistant profile")) - return "" - d = self.getParams(profile) - return d.addCallback(lambda param_xml:paramsXml2xmlUI(param_xml)) - - def getParams(self, profile_key): - """Construct xml for asked profile - 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) - if not profile: - error(_("Asking params for inexistant profile")) - return "" - - def returnCategoryXml(prof_xml): - for node in prof_xml.getElementsByTagName("category"): - if node.nodeName == "category" and node.getAttribute("name") == category: - result = node.toxml() - 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 - @param name: name of the node - @param category: category of the node - @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') ): - 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") - if name not in categories: - categories.append(cat.getAttribute("name")) - return categories - - def setParam(self, name, value, category, profile_key='@NONE@'): - """Set a parameter, return None if the parameter is not in param xml""" - #TODO: use different behaviour depending of the data type (e.g. password encrypted) - if profile_key!="@NONE@": - 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@') - 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 - self.params[profile][(category, name)] = value - self.host.bridge.paramUpdate(name, value, category, profile) - self.storage.setIndParam(category, name, value, profile) - -class Memory: - """This class manage all persistent informations""" - - def __init__(self, host): - info (_("Memory manager init")) - self.initialized = defer.Deferred() - self.host = host - self.contacts={} - self.presenceStatus={} - self.lastResource={} #tmp, will be refactored with bdd integration - self.subscriptions={} - self.private={} #used to store private value - self.server_features={} #used to store discovery's informations - self.server_identities={} - self.config = self.parseMainConf() - host.set_const('savefile_private', SAVEFILE_PRIVATE) - host.set_const('savefile_database', SAVEFILE_DATABASE) - database_file = os.path.expanduser(self.getConfig('','local_dir')+ - self.host.get_const('savefile_database')) - self.storage = SqliteStorage(database_file) - self.params=Param(host, self.storage) - self.loadFiles() - d = self.storage.initialized.addCallback(self.load) - d.chainDeferred(self.initialized) - - def parseMainConf(self): - """look for main .ini configuration file, and parse it""" - _config = SafeConfigParser(defaults=default_config) - try: - _config.read(map(os.path.expanduser, ['/etc/sat.conf', '~/sat.conf', '~/.sat.conf', 'sat.conf', '.sat.conf'])) - except: - error (_("Can't read main config !")) - - return _config - - def getConfig(self, section, name): - """Get the main configuration option - @param section: section of the config file (None or '' for DEFAULT) - @param name: name of the option - """ - if not section: - section='DEFAULT' - try: - _value = self.config.get(section, name) - except NoOptionError, NoSectionError: - _value = '' - - return os.path.expanduser(_value) if name.endswith('_path') or name.endswith('_dir') else _value - - - def loadFiles(self): - """Load parameters and all memory things from file/db""" - param_file_xml = os.path.expanduser(self.getConfig('','local_dir')+ - self.host.get_const('savefile_param_xml')) - private_file = os.path.expanduser(self.getConfig('','local_dir')+ - self.host.get_const('savefile_private')) - - #parameters template - if os.path.exists(param_file_xml): - try: - self.params.load_xml(param_file_xml) - debug(_("params template loaded")) - except: - error (_("Can't load params template !")) - self.params.load_default_params() - else: - info (_("No params template, using default template")) - self.params.load_default_params() - - #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 load(self, ignore): - """Load parameters and all memory things from db""" - #parameters data - return self.params.loadGenParams() - - def loadIndividualParams(self, profile): - """Load individual parameters for a profile - @param profile: %(doc_profile)s""" - return self.params.loadIndParams(profile) - - def purgeProfile(self, profile): - """Delete cache of data of profile - @param profile: %(doc_profile)s""" - 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')) - private_file = os.path.expanduser(self.getConfig('','local_dir')+ - self.host.get_const('savefile_private')) - - self.params.save_xml(param_file_xml) - debug(_("params saved")) - with open(private_file, 'w') as private_pickle: - pickle.dump(self.private, private_pickle) - debug(_("private values saved")) - - def getProfilesList(self): - return self.storage.getProfilesList() - - - def getProfileName(self, profile_key): - """Return name of profile from keyword - @param profile_key: can be the profile name or a keywork (like @DEFAULT@) - @return: profile name or None if it doesn't exist""" - return self.params.getProfileName(profile_key) - - 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) - - def addToHistory(self, from_jid, to_jid, message, timestamp=None, profile="@NONE@"): - assert(profile!="@NONE@") - return self.storage.addToHistory(from_jid, to_jid, message, timestamp, profile) - - def getHistory(self, from_jid, to_jid, limit=0, between=True): - return self.storage.getHistory(jid.JID(from_jid), jid.JID(to_jid), limit, between) - - def setPrivate(self, key, value): - """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 addServerFeature(self, feature, profile): - """Add a feature discovered from server - @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 self.server_identities.has_key(profile): - self.server_identities[profile] = {} - if not self.server_identities[profile].has_key((category, type)): - self.server_identities[profile][(category, type)]=set() - self.server_identities[profile][(category, type)].add(entity) - - def getServerServiceEntities(self, category, type, profile): - """Return all available entities for a service""" - if self.server_identities.has_key(profile): - return self.server_identities[profile].get((category, type), set()) - else: - return None - - def getServerServiceEntity(self, category, type, profile): - """Helper method to get first available entity for a service""" - entities = self.getServerServiceEntities(category, type, profile) - if entities == None: - warning(_("Entities not available, maybe they haven't been asked to server yet ?")) - return None - else: - return list(entities)[0] if entities else None - - def hasServerFeature(self, feature, profile_key): - """Tell if the server of the profile has the required feature""" - profile = self.getProfileName(profile_key) - if not profile: - error (_('Trying find server feature for a non-existant profile')) - return - assert(self.server_features.has_key(profile)) - return feature in self.server_features[profile] - - - def addContact(self, contact_jid, attributes, groups, profile_key): - debug("Memory addContact: %s",contact_jid.userhost()) - profile = self.getProfileName(profile_key) - if not profile: - error (_('Trying to add a contact to a non-existant profile')) - return - assert(isinstance(attributes,dict)) - assert(isinstance(groups,set)) - if not self.contacts.has_key(profile): - self.contacts[profile] = {} - self.contacts[profile][contact_jid.userhost()]=[attributes, groups] - - def delContact(self, contact_jid, profile_key): - debug("Memory delContact: %s",contact_jid.userhost()) - profile = self.getProfileName(profile_key) - if not profile: - error (_('Trying to delete a contact for a non-existant profile')) - return - if self.contacts.has_key(profile) and self.contacts[profile].has_key(contact_jid.userhost()): - del self.contacts[profile][contact_jid.userhost()] - - def getContact(self, contact_jid, profile_key): - profile = self.getProfileName(profile_key) - if not profile: - error(_('Asking a contact for a non-existant profile')) - return None - if self.contacts.has_key(profile) and self.contacts[profile].has_key(contact_jid.userhost()): - return self.contacts[profile][contact_jid.userhost()] - - def getContacts(self, profile_key): - """Return list of contacts for given profile - @param profile_key: profile key - @return list of [contact, attr, groups]""" - profile = self.getProfileName(profile_key) - if not profile: - error(_('Asking contacts for a non-existant profile')) - return [] - ret=[] - if self.contacts.has_key(profile): - for contact in self.contacts[profile]: - attr, groups = self.contacts[profile][contact] - ret.append([contact, attr, groups ]) - return ret - - def getLastResource(self, contact, profile_key): - """Return the last resource used by a contact - @param contact: contact jid (unicode) - @param profile_key: %(doc_profile_key)s""" - profile = self.getProfileName(profile_key) - if not profile: - error(_('Asking contacts for a non-existant profile')) - return "" - try: - return self.lastResource[profile][jid.JID(contact).userhost()] - except: - return "" - - def addPresenceStatus(self, contact_jid, show, priority, statuses, profile_key): - profile = self.getProfileName(profile_key) - if not profile: - error(_('Trying to add presence status to a non-existant profile')) - return - if not self.presenceStatus.has_key(profile): - self.presenceStatus[profile] = {} - if not self.lastResource.has_key(profile): - self.lastResource[profile] = {} - if not self.presenceStatus[profile].has_key(contact_jid.userhost()): - self.presenceStatus[profile][contact_jid.userhost()] = {} - resource = jid.parse(contact_jid.full())[2] or '' - if resource: - self.lastResource[profile][contact_jid.userhost()] = resource - - self.presenceStatus[profile][contact_jid.userhost()][resource] = (show, priority, statuses) - - def addWaitingSub(self, type, contact_jid, profile_key): - """Called when a subcription request is received""" - profile = self.getProfileName(profile_key) - assert(profile) - if not self.subscriptions.has_key(profile): - self.subscriptions[profile] = {} - self.subscriptions[profile][contact_jid] = type - - def delWaitingSub(self, contact_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(contact_jid): - del self.subscriptions[profile][contact_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 getPresenceStatus(self, profile_key): - profile = self.getProfileName(profile_key) - if not profile: - error(_('Asking contacts for a non-existant profile')) - return {} - if not self.presenceStatus.has_key(profile): - self.presenceStatus[profile] = {} - debug ("Memory getPresenceStatus (%s)", self.presenceStatus[profile]) - return self.presenceStatus[profile] - - 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 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)
--- a/src/tools/sqlite.py Sun Nov 20 15:34:37 2011 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,224 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -""" -SAT: a jabber client -Copyright (C) 2009, 2010, 2011 Jérôme Poisson (goffi@goffi.org) - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see <http://www.gnu.org/licenses/>. -""" - - -from logging import debug, info, warning, error -from twisted.enterprise import adbapi -from twisted.internet import defer -import os.path -import time - -class SqliteStorage(): - """This class manage storage with Sqlite database""" - - - def __init__(self, db_filename): - """Connect to the given database - @param db_filename: full path to the Sqlite database""" - self.initialized = defer.Deferred() #triggered when memory is fully initialised and ready - init_defers = [] #list of deferred we have to wait to before initialisation is complete - self.profiles={} #we keep cache for the profiles (key: profile name, value: profile id) - - info(_("Connecting database")) - new_base = not os.path.exists(db_filename) #do we have to create the database ? - self.dbpool = adbapi.ConnectionPool("sqlite3", db_filename, check_same_thread=False) - init_defers.append(self.dbpool.runOperation("PRAGMA foreign_keys = ON").addErrback(lambda x: error(_("Can't activate foreign keys")))) - if new_base: - info(_("The database is new, creating the tables")) - database_creation = [ - "CREATE TABLE profiles (id INTEGER PRIMARY KEY ASC, name TEXT, UNIQUE (name))", - "CREATE TABLE history (id INTEGER PRIMARY KEY ASC, profile_id INTEGER, source TEXT, dest TEXT, source_res TEXT, dest_res TEXT, timestamp DATETIME, message TEXT, FOREIGN KEY(profile_id) REFERENCES profiles(id))", - "CREATE TABLE param_gen (category TEXT, name TEXT, value TEXT, PRIMARY KEY (category,name))", - "CREATE TABLE param_ind (category TEXT, name TEXT, profile_id INTEGER, value TEXT, PRIMARY KEY (category,name,profile_id), FOREIGN KEY(profile_id) REFERENCES profiles(id))"] - for op in database_creation: - d = self.dbpool.runOperation(op) - d.addErrback(lambda x: error(_("Error while creating tables in database [QUERY: %s]") % op )) - init_defers.append(d) - - def fillProfileCache(ignore): - d = self.dbpool.runQuery("SELECT name,id FROM profiles").addCallback(self._profilesCache) - d.chainDeferred(self.initialized) - - defer.DeferredList(init_defers).addCallback(fillProfileCache) - - #Profiles - def _profilesCache(self, profiles_result): - """Fill the profiles cache - @param profiles_result: result of the sql profiles query""" - for profile in profiles_result: - name, id = profile - self.profiles[name] = id - - def getProfilesList(self): - """"Return list of all registered profiles""" - return self.profiles.keys() - - def hasProfile(self, profile_name): - """return True if profile_name exists - @param profile_name: name of the profile to check""" - return self.profiles.has_key(profile_name) - - def createProfile(self, name): - """Create a new profile - @param name: name of the profile - @return: deferred triggered once profile is actually created""" - def getProfileId(ignore): - return self.dbpool.runQuery("SELECT (id) FROM profiles WHERE name = ?", (name,)) - - def profile_created(profile_id): - _id = profile_id[0][0] - self.profiles[name] = _id #we synchronise the cache - - d = self.dbpool.runQuery("INSERT INTO profiles(name) VALUES (?)", (name,)) - d.addCallback(getProfileId) - d.addCallback(profile_created) - return d - - def deleteProfile(self, name): - """Delete profile - @param name: name of the profile - @return: deferred triggered once profile is actually deleted""" - def deletionError(failure): - error(_("Can't delete profile [%s]") % name) - return failure - del self.profiles[name] - d = self.dbpool.runQuery("DELETE FROM profiles WHERE name = ?", (name,)) - d.addCallback(lambda ignore: info(_("Profile [%s] deleted") % name)) - return d - - - #Params - def loadGenParams(self, params_gen): - """Load general parameters - @param params_gen: dictionary to fill - @return: deferred""" - def fillParams(result): - for param in result: - category,name,value = param - params_gen[(category, name)] = value - debug(_("loading general parameters from database")) - return self.dbpool.runQuery("SELECT category,name,value FROM param_gen").addCallback(fillParams) - - def loadIndParams(self, params_ind, profile): - """Load general parameters - @param params_ind: dictionary to fill - @param profile: a profile which *must* exist - @return: deferred""" - def fillParams(result): - for param in result: - category,name,value = param - params_ind[(category, name)] = value - debug(_("loading individual parameters from database")) - d = self.dbpool.runQuery("SELECT category,name,value FROM param_ind WHERE profile_id=?", (self.profiles[profile],)) - d.addCallback(fillParams) - return d - - def getIndParam(self, category, name, profile): - """Ask database for the value of one specific individual parameter - @param category: category of the parameter - @param name: name of the parameter - @param profile: %(doc_profile)s - @return: deferred""" - d = self.dbpool.runQuery("SELECT value FROM param_ind WHERE category=? AND name=? AND profile_id=?", (category,name,self.profiles[profile])) - d.addCallback(self.__getFirstResult) - return d - - - def setGenParam(self, category, name, value): - """Save the general parameters in database - @param category: category of the parameter - @param name: name of the parameter - @param value: value to set - @return: deferred""" - d = self.dbpool.runQuery("REPLACE INTO param_gen(category,name,value) VALUES (?,?,?)", (category, name, value)) - d.addErrback(lambda ignore: error(_("Can't set general parameter (%(category)s/%(name)s) in database" % {"category":category, "name":name}))) - return d - - def setIndParam(self, category, name, value, profile): - """Save the general parameters in database - @param category: category of the parameter - @param name: name of the parameter - @param value: value to set - @param profile: a profile which *must* exist - @return: deferred""" - d = self.dbpool.runQuery("REPLACE INTO param_ind(category,name,profile_id,value) VALUES (?,?,?,?)", (category, name, self.profiles[profile], value)) - d.addErrback(lambda ignore: error(_("Can't set individual parameter (%(category)s/%(name)s) for [%(profile)s] in database" % {"category":category, "name":name, "profile":profile}))) - return d - - #History - def addToHistory(self, from_jid, to_jid, message, timestamp=None, profile=None): - """Store a new message in history - @param from_jid: full source JID - @param to_jid: full dest JID - @param message: message - @param timestamp: timestamp in seconds since epoch, or None to use current time - """ - assert(profile!=None) - d = self.dbpool.runQuery("INSERT INTO history(source, source_res, dest, dest_res, timestamp, message, profile_id) VALUES (?,?,?,?,?,?,?)", - (from_jid.userhost(), from_jid.resource, to_jid.userhost(), to_jid.resource, timestamp or int(time.time()), - message, self.profiles[profile])) - d.addErrback(lambda ignore: error(_("Can't save following message in history: from [%(from_jid)s] to [%(to_jid)s] ==> [%(message)s]" % - {"from_jid":from_jid.full(), "to_jid":to_jid.full(), "message":message}))) - return d - - def getHistory(self, from_jid, to_jid, limit=0, between=True): - """Store a new message in history - @param from_jid: source JID (full, or bare for catchall - @param to_jid: dest JID (full, or bare for catchall - @param size: maximum number of messages to get, or 0 for unlimited - """ - def sqliteToDict(result): - result_dict = {} - for row in result: - timestamp, source, source_res, dest, dest_res, message = row - result_dict[timestamp] = ("%s/%s" % (source, source_res) if source_res else source, - "%s/%s" % (dest, dest_res) if dest_res else dest, - message) - return result_dict - - query_parts = ["SELECT timestamp, source, source_res, dest, dest_res, message FROM history WHERE"] - values = [] - - if between: - query_parts.append("(source=? OR source=?) AND (dest=? or dest=?)") - values.extend([from_jid.userhost(), to_jid.userhost(), to_jid.userhost(), from_jid.userhost()]) - else: - query_parts.append("source=? AND dest=?") - values.extend([from_jid.userhost(), to_jid.userhost()]) - if from_jid.resource: - query_parts.append("AND source_res=?") - values.append(from_jid.resource) - if to_jid.resource: - query_parts.append("AND dest_res=?") - values.append(to_jid.resource) - if limit: - query_parts.append("LIMIT ?") - values.append(limit) - d = self.dbpool.runQuery(" ".join(query_parts), values) - return d.addCallback(sqliteToDict) - - - ##Helper methods## - - def __getFirstResult(self, result): - """Return the first result of a database query - Useful when we are looking for one specific value""" - return None if not result else result[0][0]