Changeset 9508 for trunk/src/common/caps.py

Timestamp:

04/21/08 00:58:47 (7 months ago)

Author:

asterix

Message:

new XEP-0115 implementation (version 1.5)

Files:

• trunk/src/common/caps.py (modified) (8 diffs)

trunk/src/common/caps.py

@@ -21 +21 @@
 import xmpp.features_nb
 import gajim
+import helpers
 
 class CapsCache(object):
@@ -94 +95 @@
                 class CacheItem(object):
                         ''' TODO: logging data into db '''
-                        def __init__(ciself, node, version, ext=None):
+                        def __init__(ciself, hash_method, hash):
                                 # cached into db
-                                ciself.node = node
-                                ciself.version = version
-                                ciself.features = set()
-                                ciself.ext = ext
-                                ciself.exts = {}
-
-                                # set of tuples: (category, type, name)
-                                # (dictionaries are not hashable, so cannot be in sets)
-                                ciself.identities = set()
+                                ciself.hash_method = hash_method
+                                ciself.hash = hash
+
+                                @property
+                                def features():
+                                        def fget(self):
+                                                return self.getAttr('features')
+                                        def fset(self, value):
+                                                list_ = []
+                                                for feature in value:
+                                                        list_.append(self.__names.setdefault(feature, feature))
+                                                self.setAttr('features', list_)
+
+                                @property
+                                def identities():
+                                        def fget(self):
+                                                return self.getAttr('identities')
+                                        def fset(self, value):
+                                                list_ = []
+                                                for identity in value:
+                                                        list_.append(self.__names.setdefault(identity, identity))
+                                                self.setAttr('identities', list_)
 
                                 # not cached into db:
@@ -113 +127 @@
                                 ciself.queried = 0
 
-                        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))
-
-                        def __getitem__(ciself, exts):
-                                if not exts:    # (), [], None, False, whatever
-                                        return ciself
-                                if isinstance(exts, basestring):
-                                        exts=(exts,)
-                                if len(exts)==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 = [ciself]
-                                proxied.extend(ciself[(e,)] for e in exts)
-                                return ciself.CacheQuery(proxied)
-
                         def update(ciself, identities, features):
                                 # NOTE: self refers to CapsCache object, not to CacheItem
-                                self.identities=identities
-                                self.features=features
-                                self.logger.add_caps_entry(
-                                        ciself.node, ciself.version, ciself.ext,
+                                ciself.identities=identities
+                                ciself.features=features
+                                self.logger.add_caps_entry(ciself.hash_method, ciself.hash,
                                         identities, features)
 
@@ -148 +137 @@
 
                 # prepopulate data which we are sure of; note: we do not log these info
-                gajimnode = 'http://gajim.org/caps'
-
-                gajimcaps=self[(gajimnode, '0.11.1')]
-                gajimcaps.category='client'
-                gajimcaps.type='pc'
-                gajimcaps.features=set((xmpp.NS_BYTESTREAM, xmpp.NS_SI,
-                        xmpp.NS_FILE, xmpp.NS_MUC, xmpp.NS_COMMANDS,
-                        xmpp.NS_DISCO_INFO, xmpp.NS_PING, xmpp.NS_TIME_REVISED))
-                gajimcaps['cstates'].features=set((xmpp.NS_CHATSTATES,))
-                gajimcaps['xhtml'].features=set((xmpp.NS_XHTML_IM,))
-
-                # TODO: older gajim versions
+
+                gajimcaps = self[('sha-1', gajim.caps_hash)]
+                gajimcaps.identities = [gajim.gajim_identity]
+                gajimcaps.features = gajim.gajim_common_features + \
+                        gajim.gajim_optional_features
 
                 # start logging data from the net
@@ -167 +149 @@
                 # get data from logger...
                 if self.logger is not None:
-                        for node, ver, ext, identities, features in self.logger.iter_caps_data():
-                                x=self[(node, ver, ext)]
-                                x.identities=identities
-                                x.features=features
-                                x.queried=2
+                        for hash_method, hash, identities, features in \
+                        self.logger.iter_caps_data():
+                                x = self[(hash_method, hash)]
+                                x.identities = identities
+                                x.features = features
+                                x.queried = 2
 
         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.setdefault(caps[0], caps[0]), caps[1]
-                x=self.__CacheItem(node, version)
-                self.__cache[(node, version)]=x
+                if caps in self.__cache:
+                        return self.__cache[caps]
+                hash_method, hash = caps[0], caps[1]
+                x = self.__CacheItem(hash_method, hash)
+                self.__cache[(hash_method, hash)] = x
                 return x
 
-        def preload(self, account, jid, node, ver, exts):
+        def preload(self, con, jid, node, hash_method, hash):
                 ''' 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, ())]
-                qq=q
+                q = self[(hash_method, hash)]
 
                 if q.queried==0:
-                        # do query for bare node+version pair
+                        # do query for bare node+hash pair
                         # this will create proper object
                         q.queried=1
-                        account.discoverInfo(jid, '%s#%s' % (node, ver))
-
-                for ext in exts:
-                        qq=q[ext]
-                        if qq.queried==0:
-                                # do query for node+version+ext triple
-                                qq.queried=1
-                                account.discoverInfo(jid, '%s#%s' % (node, ext))
+                        con.discoverInfo(jid, '%s#%s' % (node, hash))
 
 gajim.capscache = CapsCache(gajim.logger)
@@ -211 +185 @@
 
                 # get the caps element
-                caps=presence.getTag('c')
-                if not caps: return
-
-                node, ver=caps['node'], caps['ver']
-                if node is None or ver is None:
+                caps = presence.getTag('c')
+                if not caps:
+                        return
+
+                hash_method, node, hash = caps['hash'], caps['node'], caps['ver']
+                if hash_method is None or node is None or hash is None:
                         # improper caps in stanza, ignoring
                         return
-
-                try:
-                        exts=caps['ext'].split(' ')
-                except AttributeError:
-                        # no exts means no exts, a perfectly valid case
-                        exts=[]
 
                 # we will put these into proper Contact object and ask
@@ -232 +201 @@
 
                 # start disco query...
-                gajim.capscache.preload(self, jid, node, ver, exts)
+                gajim.capscache.preload(self, jid, node, hash_method, hash)
 
                 contact=gajim.contacts.get_contact_from_full_jid(self.name, jid)
@@ -241 +210 @@
 
                 # overwriting old data
-                contact.caps_node=node
-                contact.caps_ver=ver
-                contact.caps_exts=exts
+                contact.caps_node = node
+                contact.caps_hash_method = hash_method
+                contact.caps_hash = hash
 
         def _capsDiscoCB(self, jid, node, identities, features, data):
-                contact=gajim.contacts.get_contact_from_full_jid(self.name, jid)
-                if not contact: return
-                if not contact.caps_node: return # we didn't asked for that?
-                if not node.startswith(contact.caps_node+'#'): return
-                node, ext = node.split('#', 1)
-                if ext==contact.caps_ver:       # this can be also version (like '0.9')
-                        exts=None
-                else:
-                        exts=(ext,)
+                contact = gajim.contacts.get_contact_from_full_jid(self.name, jid)
+                if not contact:
+                        return
+                if not contact.caps_node:
+                        return # we didn't asked for that?
+                if not node.startswith(contact.caps_node + '#'):
+                        return
+                node, hash = node.split('#', 1)
+                computed_hash = helpers.compute_caps_hash(identities, features,
+                        contact.caps_hash_method)
+                if computed_hash != hash:
+                        # wrong hash, forget it
+                        contact.caps_node = ''
+                        contact.caps_hash_method = ''
+                        contact.caps_hash = ''
+                        return
 
                 # if we don't have this info already...
-                caps=gajim.capscache[(node, contact.caps_ver, exts)]
-                if caps.queried==2: return
-
-                identities=set((i['category'], i['type'], i.get('name')) for i in identities)
+                caps = gajim.capscache[(contact.caps_hash_method, hash)]
+                if caps.queried == 2:
+                        return
+
                 caps.update(identities, features)
-