Author: liori Date: 2007-06-27 02:51:12 +0200 (Wed, 27 Jun 2007) New Revision: 8322
Added: trunk/src/common/caps.py Modified: trunk/src/common/contacts.py Log: Caps: Cache object
Added: trunk/src/common/caps.py =================================================================== --- trunk/src/common/caps.py (rev 0) +++ trunk/src/common/caps.py 2007-06-27 00:51:12 UTC (rev 8322) @@ -0,0 +1,240 @@ +## +## Copyright (C) 2006 Gajim Team +## +## 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; version 2 only. +## +## 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. +## + +#import xmpp +#import logger +#import gajim +from itertools import * + +class CapsCache(object): + ''' This object keeps the mapping between caps data and real disco + features they represent, and provides simple way to query that info. + It is application-wide, that is there's one object for all + connections. + Goals: + * handle storing/retrieving info from database + * cache info in memory + * expose simple interface + Properties: + * one object for all connections (move to logger.py?) + * store info efficiently (a set() of urls -- we can assume there won't be + too much of these, ensure that (X,Y,Z1) and (X,Y,Z2) has different + features. + + Connections with other objects: (TODO) + + Interface: + + # object creation + >>> cc=CapsCache(logger_object) + + >>> caps=('http://exodus.jabberstudio.org/caps', '0.9', None) # node, ver, ext + >>> muc='http://jabber.org/protocol/muc' + >>> chatstates='http://jabber.org/protocol/chatstates' + + # retrieving data + >>> muc in cc[caps].features + True + >>> muc in cc[caps] + True + >>> chatstates in cc[caps] + False + >>> cc[caps].category + 'client' + >>> cc[caps].type + 'pc' + >>> x=cc[caps] # more efficient if making several queries for one set of caps + ATypicalBlackBoxObject + >>> muc in x + True + >>> x.node + 'http://exodus.jabberstudio.org/caps' + + # retrieving data (multiple exts case) + >>> caps=('http://gajim.org/caps', '0.9', ('csn', 'ft')) + >>> muc in cc[caps] + True + + # setting data + >>> newcaps=('http://exodus.jabberstudio.org/caps', '0.9a', None) + >>> cc[newcaps].category='client' + >>> cc[newcaps].type='pc' + >>> cc[newcaps].features+=muc # same as: + >>> cc[newcaps]+=muc + >>> cc[newcaps]['csn']+=chatstates # adding data as if ext was 'csn' + # warning: no feature removal! + ''' + def __init__(self, logger=None): + ''' Create a cache for entity capabilities. ''' + # our containers: + # __names is a string cache; every string long enough is given + # another object, and we will have plenty of identical long + # strings. therefore we can cache them + # TODO: maybe put all known xmpp namespace strings here + # (strings given in xmpppy)? + # __cache is a dictionary mapping: pair of node and version maps + # to CapsCacheItem object + # __CacheItem is a class that stores data about particular + # client (node/version pair) + self.__names = {} + self.__cache = {} + class CacheQuery(object): + def __init__(cqself, proxied): + cqself.proxied=proxied + + def __getattr__(cqself, obj): + if obj!='exts': return getattr(cqself.proxied[0], obj) + return set(chain(ci.features for ci in cqself.proxied)) + + class CacheItem(object): + ''' TODO: logging data into db ''' + def __init__(ciself, node, version, ext=None): + # cached into db + ciself.node = node + ciself.version = version + ciself.features = set() + ciself.exts = {} + + ciself.identities = [] + # reported as first... important? + ciself.category = None + ciself.type = None + ciself.name = None + + ciself.cache = self + + # not cached into db: + # have we sent the query? + # 0 == not queried + # 1 == queried + # 2 == got the answer + ciself.queried = 0 + + def __iadd__(ciself, newfeature): + newfeature=self.cache.__names.setdefault(newfeature, newfeature) + ciself.features.add(newfeature) + + def __getitem__(ciself, exts): + if len(ext)==0: + return self + if len(ext)==1: + ext=exts[0] + if ext in ciself.exts: + return ciself.exts[ext] + x=CacheItem(ciself.node, ciself.version, ext) + ciself.exts[ext]=x + return x + proxied = [self] + proxied.extend(ciself[(e,)] for e in ext) + return CacheQuery(proxied) + + self.__CacheItem = CacheItem + + # prepopulate data which we are sure of; note: we do not log these info + gajim = 'http://gajim.org/caps' + + gajimcaps=self[(gajim, '0.11.1')] + gajimcaps.category='client' + gajimcaps.type='pc' + gajimcaps.features=set((common.xmpp.NS_BYTESTREAM, common.xmpp.NS_SI, + common.xmpp.NS_FILE, common.xmpp.NS_MUC, common.xmpp.NS_COMMANDS, + common.xmpp.NS_DISCO_INFO, common.xmpp.NS_PING, common.xmpp.NS_TIME_REVISED)) + gajimcaps['cstates'].features=set((common.xmpp.NS_CHATSTATES,)) + gajimcaps['xhtml'].features=set((common.xmpp.NS_XHTML_IM,)) + + # TODO: older gajim versions + + # start logging data from the net + self.__logger = logger + + # get data from logger... + if self.__logger is not None: + for node, version, category, type_, name in self.__logger.get_caps_cache(): + x=self.__clients[(node, version)] + x.category=category + x.type=type_ + x.name=name + for node, version, ext, feature in self.__logger.get_caps_features_cache(): + self.__clients[(node, version)][ext]+=feature + + def __getitem__(self, caps): + node_version = caps[:2] + if node_version in self.__cache: + return self.__cache[node_version][caps[2]] + node, version = self.__names[caps[0]], caps[1] + x=self.__cache[(node, version)]=self.__CacheItem(node, version) + return x + + def preload(self, connection, jid, node, ver, exts): + ''' Preload data about (node, ver, exts) caps using disco + query to jid using proper connection. Don't query if + the data is already in cache. ''' + q=self[(node, ver, ())] + if q.queried==0: + # do query for bare node+version pair + # this will create proper object + q.queried=1 + def callback(identities, features): + q.queried=2 + # TODO: put features and identities + xmpp.discoverInfo(con, jid, node='%s#%s' % (node, ver), callback) + + for ext in exts: + qq=q[ext] + if qq.queried==0: + # do query for node+version+ext triple + qq.queried=1 + def callback(identities, features): + qq.queried=2 + # TODO: put features and identities + xmpp.discoverInfo(con, jid, node='%s#%s' % (node, ext)) + +class ConnectionCaps(object): + ''' This class highly depends on that it is a part of Connection class. ''' + def _capsPresenceCB(self, con, presence): + ''' Handle incoming presence stanzas... This is a callback + for xmpp registered in connection_handlers.py''' + + # get the caps element + caps=presence.getTag('c') + if not caps: return + + try: + node, ver=caps['node'], caps['ver'] + except KeyError: + # improper caps in stanza, ignoring + return + + try: + exts=caps['ext'].split(' ') + except KeyError: + # no exts means no exts, a perfectly valid case + exts=[] + + # we will put these into proper Contact object and ask + # for disco... so that disco will learn how to interpret + # these caps + + jid=presence.getFrom() + + # start disco query... + gajim.capscache.preload(self, connection, jid, node, ver, exts) + + contact=gajim.contacts.get_contact_from_full_jid(self, jid) + if contact is None: + return # TODO: a way to put contact not-in-roster into Contacts + + # overwriting old data + contact.caps_node=node + contact.caps_ver=ver + contact.caps_exts=exts
Modified: trunk/src/common/contacts.py =================================================================== --- trunk/src/common/contacts.py 2007-06-26 22:52:50 UTC (rev 8321) +++ trunk/src/common/contacts.py 2007-06-27 00:51:12 UTC (rev 8322) @@ -33,6 +33,12 @@ self.priority = priority self.keyID = keyID
+ # Capabilities; filled by caps.py/ConnectionCaps object + # every time it gets these from presence stanzas + self.caps_node=None + self.caps_ver=None + self.caps_exts=None + # please read jep-85 http://www.jabber.org/jeps/jep-0085.html # we keep track of jep85 support with the peer by three extra states: # None, False and 'ask'