Changeset 96

Show
Ignore:
Timestamp:
04/11/02 16:50:33 (6 years ago)
Author:
sholloway
Message:

Conversion complete

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/RBJabber/RBJabber/Client.py

    r66 r96  
    3838from xml.sax.saxutils import escape, quoteattr 
    3939from Foundation import XMLObjectify, SubjectObserver 
     40import JID 
    4041import Base 
    41 import iqQuery 
    42 import iqAuthQuery  
    4342 
    4443#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    118117 
    119118    stream = None 
     119    SupportedNS = None 
    120120    ClientMonitors = None 
    121     SupportedNS = None 
    122121 
    123122    def __init__(self, *args, **kw): 
    …… 
    126125        apply(Base.Client.__init__, (self,) + args, kw) 
    127126         
     127        self.SupportedNS = [] 
    128128        self.ClientMonitors = [] 
    129         self.SupportedNS = [] 
    130129        self.__NextID = 0 
    131130 
    …… 
    135134 
    136135    def Authenticate(self, username, password, resource, callback=None): 
    137         if callback: 
    138             query = iqAuthQuery.iqAuthQuery(self, callback, username, password, resource) 
    139         else: query = iqAuthQuery.iqAuthQueryBase(self, username, password, resource) 
     136        import iqAuthQuery 
     137        query = iqAuthQuery.iqAuthQuery(self, username, password, resource, callback) 
    140138        return query 
    141139 
    142140    def Register(self, username, password, callback=None): 
     141        import iqQuery 
    143142        strXML = '<username>%s</username><password>%s</password>' % (username, password) 
    144         if callback: 
    145             query = iqQuery.iqQuery(self, callback) 
    146         else: query = iqQuery.iqQueryBase(self) 
     143        query = iqQuery.iqQuery(self, callback) 
    147144        query.SendQuery("jabber:iq:register", '', 'set', strXML) 
    148145        return query 
    149146 
    150     def QueryRoster(self, callback): 
    151         if callback: 
    152             query = iqQuery.iqQuery(self, callback) 
    153         else: query = iqQuery.iqQueryBase(self) 
    154         query.SendQuery("jabber:iq:roster")  
    155         return query 
     147    def QueryRoster(self, callback=None): 
     148        import iqRosterQuery 
     149        return iqRosterQuery.iqRosterQuery(self, callback) 
    156150 
    157151    def BrowseJID(self, toJID, callback): 
    158         if callback: 
    159             query = iqQuery.iqQuery(self, callback) 
    160         else: query = iqQuery.iqQueryBase(self) 
     152        import iqQuery 
     153        query = iqQuery.iqQuery(self, callback) 
    161154        query.SendQuery("jabber:iq:browse", toJID)  
    162155        return query 

  • trunk/RBJabber/RBJabber/JID.py

    r94 r96  
    4545_restrResource = '''\S+''' 
    4646reJabberURL = re.compile('''(?:jabber://)?(%s)''' % (_restrServer)) 
    47 reJabberJID = re.compile('''(%s)@(%s)(?:/(%s))?''' % (_restrID, _restrServer, _restrResource)) 
     47reJabberJID = re.compile('''(?:(%s)@)?(%s)(?:/(%s))?''' % (_restrID, _restrServer, _restrResource)) 
    4848 
    4949__all__ = ['reJabberURL', 'reJabberJID'] 
    …… 
    5555def splitnorm(strJID, start=1, end=4): 
    5656    result = reJabberJID.split(strJID)[start:end] 
    57     return [x.lower() for x in result[1-start:3-start]] + result[3-start:] 
     57    return [x and x.lower() or x for x in result[1-start:3-start]] + result[3-start:] 
    5858 
    5959def split(strJID, start=1, end=4): 
    …… 
    7272    return 0 == apply(cmp_, args, kw) 
    7373 
     74def contains(strJIDa, strJIDb): 
     75    jida = filter(None, splitnorm(strJIDa, end=4)) 
     76    jidb = filter(None, splitnorm(strJIDb, end=3))[-len(jida):] 
     77    return jida == jidb 
     78 
    7479def join(*args): 
    7580    if isinstance(args[0], (tuple, list)): 
    7681        args = tuple(args[0]) 
    7782    args = filter(None, args) 
    78     if len(args) > 2: 
     83    if len(args) == 3: 
    7984        return JID('%s@%s/%s' % args) 
    80     elif args: return JID('%s@%s' % args) 
     85    elif len(args) == 2: 
     86        return JID('%s@%s' % args) 
     87    elif len(args) == 1: 
     88        return args[0] 
    8189    else: return '' 
    8290 
    …… 
    125133        return cmp_(self, other) >= 0 
    126134 
     135    def __contains__(self, other): 
     136        return contains(self, other) 
     137         
    127138    def __hash__(self): 
    128139        return hash(tuple(self.splitnorm())) 
    …… 
    136147    j2 = JID('User.Name@Jabber.org/Resource') 
    137148    j3 = JID('User.Name@Jabber.org/ReSoUrCe') 
     149    j4 = JID('conference.jabber.org') 
    138150 
    139     assert(j1 == j2) 
    140     assert(j1 >= j2) 
    141     assert(j1 <= j2) 
    142     assert(j1 != j3) 
    143     assert(j2 != j3) 
    144     assert(j3 < j1) 
    145     assert(j1 > j3) 
    146     assert(j3 < j2) 
    147     assert(j2 > j3) 
    148     assert(j1.splitnorm() == j2.splitnorm() != j3.splitnorm()) 
    149     assert(j1.splitnorm(1,3) == j2.splitnorm(1,3) == j3.splitnorm(1,3)) 
    150     assert(hash(j1) == hash(j2)) 
    151     assert(hash(j1) != hash(j3)) 
    152     assert(hash(j2) != hash(j3)) 
     151    assert j1 in JID('user.name@Jabber.org') 
     152    assert j3 in JID('JaBBer.org') 
     153    assert j2 not in j3 
     154 
     155    assert j4.normalize() == j4 
     156    assert j4.username() is None 
     157    assert j4.server() == j4 
     158    assert j4.resource() is None 
     159    assert j4.noresource() == j4 
     160 
     161    assert j1 == j2 
     162    assert j1 >= j2 
     163    assert j1 <= j2 
     164    assert j1 != j3 
     165    assert j2 != j3 
     166    assert j3 < j1 
     167    assert j1 > j3 
     168    assert j3 < j2 
     169    assert j2 > j3 
     170    assert j1.splitnorm() == j2.splitnorm() != j3.splitnorm() 
     171    assert j1.splitnorm(1,3) == j2.splitnorm(1,3) == j3.splitnorm(1,3) 
     172    assert hash(j1) == hash(j2) 
     173    assert hash(j1) != hash(j3) 
     174    assert hash(j2) != hash(j3) 
    153175 
    154176    dictTest = {} 
    …… 
    156178    dictTest[j2] = 1 
    157179    dictTest[j3] = 1 
    158     assert(len(dictTest)==2) 
     180    # Length should be 2 because j2 and j1s' hashes should be identical 
     181    assert len(dictTest)==2 
    159182     
    160183#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

  • trunk/RBJabber/RBJabber/JabberConnection.py

    r89 r96  
    7979        self._socket.connect((params[0], port)) 
    8080        self.fileno = self._socket.fileno 
    81         self.ServerJID = params[0] 
     81        self.ServerJID = JID.JID(params[0]) 
    8282 
    8383        # Create our xml parser 
    …… 
    9898    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    9999 
     100    def BuildJID(self, username='', server='', resource=''): 
     101        return JID.JID.join(username, server or self.ServerJID, resource) 
     102         
    100103    def SendXML(self, xmlData): 
    101104        self._sendData += xmlData 

  • trunk/RBJabber/RBJabber/JabberObserver.py

    r94 r96  
    5353        else: return 0 
    5454     
    55 class MatchAttributesEx(object): 
    56     def __init__(self, attributes): 
     55class MatchAttributesRE(object): 
     56    def __init__(self, **attributes): 
    5757        import re 
    5858        self._MatchInfo = {} 
    …… 
    6969        else: return 1 
    7070 
    71 class MatchAttributes(MatchAttributesEx): 
     71class MatchAttributes(object): 
    7272    def __init__(self, **attributes): 
    73         super(MatchAttributes, self).__init__(attributes) 
     73        self._MatchInfo = attributes 
     74 
     75    def __call__(self, value): 
     76        for key, compareto in self._MatchInfo.iteritems(): 
     77            if compareto != getattr(value, key, None): 
     78                return 0 
     79        else: return 1 
    7480 
    7581class MatchHasAttribute(object): 
    …… 
    7884         
    7985    def __call__(self, value): 
    80         return hasattr(self._MatchInfo, value) 
     86        return hasattr(value, self._MatchInfo) 
    8187 
    8288class MatchHasNode(object): 

  • trunk/RBJabber/RBJabber/MessageRouter.py

    r87 r96  
    3535#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    3636 
    37 from Foundation.SubjectObserver.Subject import Subject 
    38 from Foundation.SubjectObserver.Observer import Observer 
    39 from Foundation.SubjectObserver.BidableSubject import BidableSubjectMixin  
    40 import JID 
     37from JabberSubject import FromJIDSubjectMixin 
     38from Foundation.SubjectObserver.CategorySubject import CategorySubjectBaseMixin 
    4139 
    4240#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    4442#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4543 
    46 class MessageRouterBase(BidableSubjectMixin): 
    47     def __init__(self, JC, MessageMapEntryClass=None): 
    48         self._observer = Observer(self.Update, self.Bid) 
    49         JC.stream.AddObserver('message', self._observer) 
    50         self._UpdateMap = {} 
    51         if not MessageMapEntryClass: 
    52             MessageMapEntryClass = Subject 
    53         self.MessageMapEntryClass = MessageMapEntryClass 
    54  
    55     def Update(self, subject, **UpdateDict): 
    56         pass 
    57  
    58     def Bid(self, subject, **UpdateDict): 
    59         message = UpdateDict.get('message', None) 
    60         for index in self._UpdateMapXForm(message): 
    61             UpdateSubject = self._UpdateMap.get(index, None) 
    62             if UpdateSubject: 
    63                 for obs in UpdateSubject.Observers: 
    64                     subject._GetBid(obs, UpdateDict) 
    65  
    66     def Get(self, index, bCreateSubject=1): 
    67         index = self._UpdateIndexXForm(index)[0] 
    68         result = self._UpdateMap.get(index, None) 
    69         if result is None and bCreateSubject: 
    70             result = self.MessageMapEntryClass() 
    71             self._UpdateMap[index] = result 
    72         return result 
     44class MessageRouterByFrom(FromJIDSubjectMixin): 
     45    def __init__(self, JC): 
     46        JC.stream.AddObserver('message', self) 
    7347 
    7448#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    7549 
    76 class MessageRouterByFrom(MessageRouterBase): 
    77     def _UpdateIndexXForm(self, FromJID): 
    78         return (JID.normalize(FromJID),) 
     50class MessageRouterByType(CategorySubjectBaseMixin): 
     51    def __init__(self, JC): 
     52        JC.stream.AddObserver('message', self) 
    7953 
    80     def _UpdateMapXForm(self, node): 
    81         return self._UpdateIndexXForm(node.from_) 
     54    def Bid(self, subject, **UpdateDict): 
     55        for value in UpdateDict.itervalues(): 
     56            for obs in self._ObserverList(value.type): 
     57                subject._GetBid(obs, UpdateDict) 
    8258 
    8359#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    8460 
    85 class MessageRouterByType(MessageRouterBase): 
    86     def _UpdateIndexXForm(self, index): 
    87         return (index.lower(),) 
     61class MessageRouterByID(CategorySubjectBaseMixin): 
     62    def __init__(self, JC): 
     63        JC.stream.AddObserver('message', self) 
    8864 
    89     def _UpdateMapXForm(self, node): 
    90         return self._UpdateIndexXForm(node.type) 
     65    def Bid(self, subject, **UpdateDict): 
     66        for value in UpdateDict.itervalues(): 
     67            for obs in self._ObserverList(value.id): 
     68                subject._GetBid(obs, UpdateDict) 
    9169 
    9270#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    9371 
    94 class MessageRouterByID(MessageRouterBase): 
    95     def _UpdateIndexXForm(self, index): 
    96         return (index.lower(),) 
     72class MessageRouterByThread(CategorySubjectBaseMixin): 
     73    def __init__(self, JC): 
     74        JC.stream.AddObserver('message', self) 
    9775 
    98     def _UpdateMapXForm(self, node): 
    99         return self._UpdateIndexXForm(node.id) 
     76    def Bid(self, subject, **UpdateDict): 
     77        for value in UpdateDict.itervalues(): 
     78            thread = ':'.join(map(str, value.Elements(value='thread'))) 
     79            for obs in self._ObserverList(thread): 
     80                subject._GetBid(obs, UpdateDict) 
    10081 
    101 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    102  
    103 class MessageRouterByThread(MessageRouterBase): 
    104     def _UpdateIndexXForm(self, index): 
    105         return (index.upper(),) 
    106  
    107     def _UpdateMapXForm(self, node): 
    108         thread = ':'.join(map(str, node.Elements(node='thread'))) 
    109         return self._UpdateIndexXForm(thread) 
    110  

  • trunk/RBJabber/RBJabber/SubscribeApproveResponse.py

    r88 r96  
    3636 
    3737import weakref 
    38 from Foundation.SubjectObserver.Observer import Observer 
    39 from Foundation.WeakBind import BindCallable 
    4038from xml.sax.saxutils import escape, quoteattr 
     39import JabberObserver as JObs 
     40import JID 
    4141  
    4242#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    4444#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4545 
    46 class SubscribeApproveResponse: 
    47     BidValue = 1 
    48      
    49     def __init__(self, JabberClient): 
    50         self.JC = weakref.ref(JabberClient) 
    51         self._observer = Observer(self.Update, self.Bid) 
    52         self.JC().stream.AddObserver('presence', self._observer) 
    53         self._SelfLink(1) 
     46class SubscribeApproveResponse(JObs.JabberObserver): 
     47    def __init__(self, JC, BidValue=1): 
     48        JObs.JabberObserver.__init__(self, self.ApprovePresence, JObs.MatchAttributesRE(type='^(?:subscribe|unsubscribe)$'), BidValue) 
     49        JC.stream.AddObserver('presence', self) 
    5450 
    55     def Bid(self, subject, presence): 
    56         bMatch = presence.type in ['subscribe', 'unsubscribe'] 
    57         return bMatch and self.BidValue or 0 
    58  
    59     def Update(self, subject, presence): 
     51    def ApprovePresence(self, stream, presence): 
    6052        presence.to = presence.from_ 
    6153        del presence.from_ 
    6254        presence.type += 'd' # set to subscribed/unsubscribed 
    63         self.JC().SendXML(presence._toPrettyXML()) 
     55        presence._client.SendXML(presence._toPrettyXML()) 
    6456 
    65     def _SelfLink(self, bLink): 
    66         cm = self.JC().ClientMonitors 
    67         if bLink: 
    68             if self not in cm: cm.append(self) 
    69         else:  
    70             if self in cm: cm.remove(self) 
    71   

  • trunk/RBJabber/RBJabber/Test.py

    r95 r96  
    3131##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    3232 
    33 from Client import * 
    34 from PresenceMap import PresenceMap 
    35 from MessageRouter import MessageRouterByType 
    36 from Foundation.SmartSelect import SmartSelect 
    37 from iqQuery import iqQuery 
    38 from iqResponse import iqResponse  
    39 from iqTimeResponse import iqTimeResponse 
    40 from iqVersionResponse import iqVersionResponse 
    41 from iqBrowseResponse import iqBrowseResponse 
    42 from iqRosterQuery import iqRosterQuery 
    43 from JabberSubject import FromJIDSubject 
    44 from SubscribeApproveResponse import SubscribeApproveResponse 
    45 from pprint import pprint 
    46 import sys 
     33#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     34#~ Imports  
     35#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     36 
     37import Client 
     38import iqTimeResponse 
     39import iqVersionResponse 
     40import iqBrowseResponse 
     41import SubscribeApproveResponse 
     42 
     43#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     44#~ Definitions  
     45#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     46 
     47def _test(server, username, password, resource='Foundation.Jabber.Test'): 
     48    try: 
     49        jc = Client.Client(server) 
     50        jc._SetDebug(sys.stdout, sys.stdout) 
     51 
     52        #jc.Register(username, password) 
     53        authq = jc.Authenticate(username, password, resource) 
     54         
     55        #pm = PresenceMap(jc) 
     56 
     57        jc.BrowseJID('www.runeblade.com', None) 
     58 
     59        jc.Presence() 
     60 
     61        jc.Roster = jc.QueryRoster() 
     62 
     63        jc.Responses = [] 
     64        jc.Responses.append(iqTimeResponse.iqTimeResponse(jc)) 
     65        jc.Responses.append(iqVersionResponse.iqVersionResponse(jc, 'RuneBlade Foundation Jabber Test', '0.2')) 
     66        jc.Responses.append(iqBrowseResponse.iqBrowseResponse(jc)) 
     67        jc.Responses.append(SubscribeApproveResponse.SubscribeApproveResponse(jc)) 
     68         
     69        while 1: jc.Process(0.5) 
     70    except KeyboardInterrupt: 
     71        jc.SendXML('''<presence type="unavailable" />''') 
    4772 
    4873#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4974 
    50 def _printMessage(subject, **UpdateDict): 
    51     print 
    52     print "Message from %r" % value.from_ 
    53     for value in UpdateDict.itervalues(): print value._toPrettyXML() 
    54     print 
     75if __name__ == '__main__':  
     76    import sys 
     77    dictLogin = {'server':'www.runeblade.com', 'username':'shane.test1', 'password':'testing'} 
     78    strEval = ('","'.join(sys.argv[1:])).replace('=','":"') 
     79    if strEval: 
     80        strEval = ('{"%s"}'%strEval) 
     81        dictLogin.update(eval(strEval, {}, {})) 
     82    apply(_test, tuple(), dictLogin) 
    5583 
    56 def _printTypedMessage(subject,**UpdateDict): 
    57     value = UpdateDict['message'] 
    58     print 
    59     print "$$$ Message from %r" % (value.from_) 
    60     print value._toPrettyXML() 
    61     print 
    62  
    63 def _printIQ(subject, **UpdateDict): 
    64     print 
    65     print "IQ from %r" % getattr(value, 'from', '') 
    66     for value in UpdateDict.itervalues(): print value._toPrettyXML() 
    67     print 
    68  
    69 def _printPresence(subject, **UpdateDict): 
    70     print 
    71     for value in UpdateDict.itervalues():  
    72         print "Presence from %r" % value.from_.normalize() 
    73         print value._toPrettyXML() 
    74     print 
    75  
    76 def _printRegister(subject, iq): 
    77     print 
    78     if iq.type == 'error': 
    79         print 'Registration: Error -- %s' % iq.error[0] 
    80     else: print 'Registration: Successful' 
    81     print 
    82  
    83 def _printAuth(subject, iq): 
    84     print 
    85     if iq.type == 'error': 
    86         print 'Authorization: Error -- %s' % iq.error[0] 
    87     else: print 'Authorization: Successful' 
    88     print 
    89  
    90 def _printBrowse(subject, **UpdateDict): 
    91     print 
    92     print "Browse" 
    93     for value in UpdateDict.itervalues(): print value._toPrettyXML() 
    94     print 
    95  
    96 def _printRoster(subject, name, roster): 
    97     print  
    98     print "Roster Received!" 
    99     for each in getattr(roster.query[0], 'item', []): 
    100         print each._toPrettyXML() 
    101     print 
    102  
    103 def _printVersion(subject, **UpdateDict): 
    104     print  
    105     print "Version Received!" 
    106     for value in UpdateDict.itervalues(): print value._toPrettyXML() 
    107     print 
    108  
    109 def _printIt(subject, **UpdateDict): 
    110     print  
    111     print "PRINT IT!!!" 
    112     for value in UpdateDict.itervalues(): print value._toPrettyXML() 
    113     print 
    114  
    115 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    116  
    117 def _test(**dictLogin): 
    118     try: 
    119         import sys 
    120         strEval = ('","'.join(sys.argv[1:])).replace('=','":"') 
    121         if strEval: 
    122             strEval = ('{"%s"}'%strEval) 
    123             dictLogin.update(eval(strEval, {}, {})) 
    124  
    125         jc = Client(dictLogin['server']) 
    126         jc._SetDebug(sys.stdout, sys.stdout) 
    127         process = SmartSelect() 
    128         process.append(jc) 
    129         del dictLogin['server'] 
    130  
    131         for x in xrange(2): process(1) 
    132  
    133         dictLogin['callback'] = _printRegister 
    134         dictRegister = dictLogin.copy() 
    135         del dictRegister['resource'] 
    136         #apply(jc.Register, tuple(), dictRegister) 
    137  
    138         dictLogin['callback'] = _printAuth 
    139         apply(jc.Authenticate, tuple(), dictLogin) 
    140          
    141         jc.stream.AddObserver('message', _printMessage) 
    142         jc.stream.AddObserver('presence', _printPresence) 
    143  
    144         def OnShanePresence(stream, presence): print "HELLO SHANE!!!" 
    145         js = FromJIDSubject() 
    146         jc.stream.AddObserver('presence', js) 
    147         js.AddObserver('shane.holloway@www.runeblade.com', OnShanePresence) 
    148          
    149         pm = PresenceMap(jc) 
    150         router = MessageRouterByType(jc) 
    151         obs = SubjectObserver.Observer.Observer(_printTypedMessage) 
    152         obs.Bid = 10 
    153         router.Get('message').AddObserver(obs) 
    154         router.Get('groupchat').AddObserver(obs) 
    155         #router.Get('chat').AddObserver(obs) 
    156         router.Get('headline').AddObserver(obs) 
    157  
    158         for x in xrange(2): process(1) 
    159         jc.SendXML('''<presence type='available' />''') 
    160         for x in xrange(2): process(1) 
    161  
    162         jc.BrowseJID('www.runeblade.com', None) 
    163         roster = iqRosterQuery(jc) 
    164         #iqQuery(jc, _printRoster).SendQuery("jabber:iq:roster") 
    165         #iqQuery(jc, _printVersion).SendQuery("jabber:iq:version", 'shane.holloway@www.runeblade.com/Laptop') 
    166         #iqQuery(jc, _printVersion).SendQuery("jabber:iq:version", 'shane.holloway@myjabber.net') 
    167         iqTimeResponse(jc) 
    168         iqVersionResponse(jc, 'RuneBlade Foundation Jabber', '0.01') 
    169         iqBrowseResponse(jc) 
    170         SubscribeApproveResponse(jc) 
    171          
    172         while 1: process(1) 
    173     except KeyboardInterrupt: 
    174         jc.SendXML('''<presence type="unavailable" />''') 
    175  
    176     pprint(pm.ByJID) 
    177  
    178 _test(server='www.runeblade.com', username='shane.test1', password='testing', resource='Python-Test') 
    179  

  • trunk/RBJabber/RBJabber/iqAuthQuery.py

    r86 r96  
    3535#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    3636 
    37 import weakref 
    38 import select 
    39 import sha 
    40 from Foundation.SubjectObserver.Observer import Observer 
     37import weakref, sha 
     38from xml.sax.saxutils import escape, quoteattr 
    4139from Foundation.WeakBind import BindCallable 
    42 from xml.sax.saxutils import escape, quoteattr 
    43 from iqQuery import iqQueryBase, Subject 
     40from iqQuery import iqQueryBase 
    4441  
    4542#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    4744#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4845 
    49 class iqAuthQueryBase(iqQueryBase): 
    50     def __init__(self, JabberClient, username, password, resource): 
    51         self.JC = weakref.ref(JabberClient) 
    52         self._observer = Observer(self.Update, self.Bid) 
    53         self.JC().stream.AddObserver('iq', self._observer) 
     46class iqAuthQuery(iqQueryBase): 
     47    def __init__(self, JC, username, password, resource, callback=None, BidValue=1): 
     48        self.OnAuthCallback = BindCallable(callback) 
     49        iqQueryBase.__init__(self, JC, self.OnAuthReply, BidValue) 
    5450 
    5551        while not self.JC()._elements: 
    …… 
    6056 
    6157        self.JC().information.authorized = 0 
    62         self.JC().information.username = username 
    63         self.JC().information.resource = resource 
    64         self.JC().information.jid = '%s@%s/%s' % (username, self.JC().ServerJID, resource) 
     58        self.JC().information.jid = self.JC().BuildJID(username, None, resource) 
    6559         
    66         self.idQuery = self.JC()._GetNextID() 
    67         self.JC().SendXML('''<iq type='set' id='%s'><query xmlns='jabber:iq:auth'>%s</query></iq>''' % (self.idQuery, xmlAuthInfo)) 
    68         self._SetLink(1) 
     60        self.SendQuery('jabber:iq:auth', typeQuery='set', xmlQueryPayload=xmlAuthInfo) 
    6961 
    70     def Bid(self, subject, **UpdateDict): 
    71         iq = UpdateDict.get('iq', None) 
    72         if iq: 
    73             bMatch = iq.id == self.idQuery 
    74             if bMatch: bMatch = iq.type in ['result', 'error'] 
    75             return bMatch and 1 or -1 
    76         return -1 
    77      
    78     def Update(self, subject, **UpdateDict): 
    79         iq = UpdateDict['iq'] 
     62    def OnAuthReply(self, stream, iq): 
    8063        if iq.type == 'result': 
    8164            self.JC().information.authorized = 1 
    82         self._SetLink(0) 
     65        if self.OnAuthCallback: 
     66            self.OnAuthCallback(stream, iq) 
    8367 
    84 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    85  
    86 class iqAuthQuerySubject(iqAuthQueryBase, Subject): 
    87     def __init__(self, *args, **kw): 
    88         apply(iqAuthQueryBase.__init__, (self, ) + args, kw) 
    89         Subject.__init__(self) 
    90  
    91     def Update(self, subject, **UpdateDict): 
    92         # Notify our callback 
    93         apply(iqAuthQueryBase.Update, (self, subject,), UpdateDict) 
    94         self.UpdateObserversEx(UpdateDict) 
    95      
    96 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    97  
    98 class iqAuthQuery(iqAuthQueryBase): 
    99     def __init__(self, JabberClient, ReplyCallback, *args, **kw): 
    100         apply(iqAuthQueryBase.__init__, (self, JabberClient) + args, kw) 
    101         self.ReplyCallback = BindCallable(ReplyCallback) 
    102  
    103     def Update(self, subject, **UpdateDict): 
    104         # Notify our callback 
    105         apply(iqAuthQueryBase.Update, (self, subject,), UpdateDict) 
    106         apply(self.ReplyCallback, (subject,), UpdateDict) 
    107  

  • trunk/RBJabber/RBJabber/iqBrowseResponse.py

    r66 r96  
    4545 
    4646class iqBrowseResponse(iqResponseBase): 
    47     def __init__(self, JC, Bid=1): 
    48         iqResponseBase.__init__(self, JC) 
     47    def __init__(self, JC, BidValue=1): 
     48        iqResponseBase.__init__(self, JC, self.OnIQBrowseRequest, BidValue=BidValue) 
    4949        self.AnswerQuery("jabber:iq:browse") 
    50         self.Bid = 1 
    5150 
    52     def __call__(self, subject, **UpdateDict): 
    53         iq = UpdateDict['iq'] 
     51    def OnIQBrowseRequest(self, subject, iq): 
    5452        iq.to = iq.from_ 
    5553        del iq.from_ 
    …… 
    6159        strResult += '''</user></iq>''' 
    6260 
    63         self.JC().SendXML(strResult) 
     61        iq._client.SendXML(strResult) 

  • trunk/RBJabber/RBJabber/iqQuery.py

    r88 r96  
    3636 
    3737import weakref 
     38from xml.sax.saxutils import escape, quoteattr 
    3839from Foundation.WeakBind import BindCallable 
    39 from Foundation.SubjectObserver.Subject import Subject 
    40 from Foundation.SubjectObserver.Observer import Observer 
    41 from xml.sax.saxutils import escape, quoteattr 
     40import JabberObserver as JObs 
    4241import JID 
    4342  
    …… 
    4645#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4746 
    48 class iqQueryBase: 
    49     def __init__(self, JabberClient, BidValue=1): 
    50         self.BidValue = BidValue 
    51         if isinstance(JabberClient, weakref.ReferenceType): 
    52             self.JC = JabberClient 
    53         else:  
    54             self.JC = weakref.ref(JabberClient) 
    55         self._observer = Observer(self.Update, self.Bid) 
     47class iqQueryBase(JObs.JabberObserver): 
     48    def __init__(self, JC, callback=None, BidValue=1): 
     49        JObs.JabberObserver.__init__(self, callback, BidValue=BidValue) 
     50        if isinstance(JC, weakref.ReferenceType): 
     51            self.JC = JC 
     52        else: self.JC = weakref.ref(JC) 
     53        self.JC().stream.AddObserver('iq', self) 
    5654 
    57     def Bid(self, subject, iq): 
    58         if iq: 
    59             # if it is an iq with the same id 
    60             bMatch = iq.id == self.idQuery 
    61             # and a compatible type 
    62             if bMatch: bMatch = iq.type in ['result', 'error'] 
    63             # and a it matches the jid we sent it to 
    64             if bMatch: bMatch = (not self.jidQuery or JID.compare(iq.from_, self.jidQuery)) 
    65             # and the query result namespace is the same 
    66             # if bMatch: bMatch = [q for q in iq._elements if q[0][0] == self.nsQuery] and 1 or 0 
    67             # then we have a match 
    68             return bMatch and self.BidValue or 0 
    69         return 0 
    70      
    71     def Update(self, subject, **UpdateDict): 
    72         # Unhook ourselves 
    73         self.JC().stream.RemoveObserver(self._observer) 
    74         # Unlink our self reference since we are done 
    75         self._SetLink(0) 
     55    def SendQuery(self, nsQuery, jidQuery='', typeQuery='get', xmlQueryPayload='', idQuery=None, bSetLink=1): 
     56        # Get a new id 
     57        idQuery = idQuery or self.JC()._GetNextID() 
    7658 
    77     def _SetLink(self, bLink): 
    78         cm = self.JC().ClientMonitors 
    79         if bLink: 
    80             if self not in cm: cm.append(self) 
    81         else:  
    82             if self in cm: cm.remove(self) 
    83   
    84     def SendQuery(self, nsQuery, jidQuery='', typeQuery='get', xmlQueryPayload=''): 
    85         # Make a self reference while we are still querying 
    86         self._SetLink(1) 
    87         # Lets observer the jabber stream 
    88         self.JC().stream.AddObserver('iq', self._observer) 
    8959        # Setup our match attributes 
    90         self.nsQuery = nsQuery 
    91         self.jidQuery = jidQuery 
    92         self.idQuery = self.JC()._GetNextID() 
     60        del self.Match[:] 
     61        if jidQuery: self.Match.append(JObs.MatchAttributes(from_=JID.JID(jidQuery))) 
     62        if idQuery: self.Match.append(JObs.MatchAttributes(id=idQuery)) 
     63        self.Match.append(JObs.MatchHasChildNamespace(nsQuery)) 
     64         
    9365        # and finally send the query 
    94         self._DoSendQuery({'type':typeQuery, 'id':self.idQuery, 'to':jidQuery}, nsQuery, xmlQueryPayload) 
     66        self.JC().SendXML(self._BuildQuery(nsQuery, xmlQueryPayload, type=typeQuery, id=idQuery, to=jidQuery)) 
    9567        return self 
    9668     
    97     def _DoSendQuery(self, attrQuery, nsQuery, xmlQueryPayload): 
     69    def _BuildQuery(self, nsQuery, xmlQueryPayload, **attrQuery): 
     70        # Build the XML attribute string 
    9871        strAttributes = ' '.join([ ('%s=%s' % (a[0], quoteattr(a[1]))) for a in attrQuery.iteritems() if a[1]] ) 
    99         result = '''<iq %s ><query xmlns=%s>%s</query></iq>''' % (strAttributes, quoteattr(nsQuery), xmlQueryPayload) 
    100         self.JC().SendXML(result) 
     72        # Return the built xml 
     73        return '''<iq %s ><query xmlns=%s>%s</query></iq>''' % (strAttributes, quoteattr(nsQuery), xmlQueryPayload) 
    10174 
    10275#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    10376 
    104 class iqQuerySubject(iqQueryBase, Subject): 
    105     def __init__(self, JabberClient): 
    106         iqQueryBase.__init__(self, JabberClient) 
    107         Subject.__init__(self) 
     77class iqQuery(iqQueryBase): 
     78    pass 
    10879 
    109     def Update(self, subject, **UpdateDict): 
    110         # Notify our callback 
    111         apply(iqQueryBase.Update, (self, subject,), UpdateDict) 
    112         self.UpdateObserversEx(UpdateDict) 
    113      
    114 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    115  
    116 class iqQuery(iqQueryBase): 
    117     def __init__(self, JabberClient, ReplyCallback): 
    118         iqQueryBase.__init__(self, JabberClient) 
    119         self.ReplyCallback = BindCallable(ReplyCallback) 
    120  
    121     def Update(self, subject, **UpdateDict): 
    122         # Notify our callback 
    123         apply(iqQueryBase.Update, (self, subject,), UpdateDict) 
    124         apply(self.ReplyCallback, (subject,), UpdateDict) 
    125  

  • trunk/RBJabber/RBJabber/iqResponse.py

    r74 r96  
    3636 
    3737import weakref 
    38 from Foundation.SubjectObserver.Observer import Observer 
     38from xml.sax.saxutils import escape, quoteattr 
    3939from Foundation.WeakBind import BindCallable 
    40 from xml.sax.saxutils import escape, quoteattr 
     40import JabberObserver as JObs 
     41import JID 
    4142  
    4243#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    4445#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4546 
    46 class iqResponseBase: 
    47     BidValue = 1 
    48      
    49     def __init__(self, JabberClient): 
    50         self.JC = weakref.ref(JabberClient) 
    51         self._observer = Observer(self.Update, self.Bid) 
     47class iqResponseBase(JObs.JabberObserver): 
     48    def __init__(self, JC, callback=None, BidValue=1): 
     49        JObs.JabberObserver.__init__(self, callback, BidValue=BidValue) 
     50        if isinstance(JC, weakref.ReferenceType): 
     51            self.JC = JC 
     52        else: self.JC = weakref.ref(JC) 
     53        self.JC().stream.AddObserver('iq', self) 
    5254 
    53     def Bid(self, subject, **UpdateDict): 
    54         iq = UpdateDict.get('iq', None) 
    55         if iq: 
    56             # and a compatible type 
    57             bMatch = iq.type == self.typeQuery 
    58             # and the query result namespace is the same 
    59             if bMatch: bMatch = iq.Elements(namespace=self.nsQuery) and 1 or 0 
    60             # then we have a match 
    61             return bMatch and self.BidValue or 0 
    62         return 0 
     55    def AnswerQuery(self, nsQuery, typeQuery='get'): 
     56        # Lets observer the jabber stream 
     57        if nsQuery not in self.JC().SupportedNS: 
     58            self.JC().SupportedNS.append(nsQuery) 
    6359 
    64     def Update(self, subject, **UpdateDict): 
    65         pass 
     60        del self.Match[:] 
     61        self.Match.append(JObs.MatchHasChildNamespace(nsQuery)) 
     62        self.Match.append(JObs.MatchAttributes(type=typeQuery)) 
    6663 
    67     def _SelfLink(self, bLink): 
    68         cm = self.JC().ClientMonitors 
    69         if bLink: 
    70             if self not in cm: cm.append(self) 
    71         else:  
    72             if self in cm: cm.remove(self) 
    73   
    74     def AnswerQuery(self, nsQuery, typeQuery='get'): 
    75         # Make a self reference while we are still querying 
    76         self._SelfLink(1) 
    77         # Lets observer the jabber stream 
    78         self.JC().stream.AddObserver('iq', self._observer) 
    79         self.JC().SupportedNS.append(nsQuery) 
    8064        # Setup our match attributes 
    81         self.nsQuery = nsQuery 
    82         self.typeQuery = typeQuery 
    8365        return self 
    84      
    85 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    86      
    87 class iqResponse(iqResponseBase): 
    88     def __init__(self, JabberClient, ReplyCallback): 
    89         iqResponseBase.__init__(self, JabberClient) 
    90         self.Update = BindCallable(ReplyCallback) 
    9166 

  • trunk/RBJabber/RBJabber/iqRosterQuery.py

    r87 r96  
    3737import weakref 
    3838from xml.sax.saxutils import escape, quoteattr 
    39 from Foundation.SubjectObserver.Observer import Observer 
    40 from iqQuery import iqQueryBase, Subject 
     39from Foundation.WeakBind import BindCallable 
     40from Foundation.SubjectObserver.CategorySubject import CategorySubject 
     41from iqQuery import iqQueryBase 
    4142import JID  
    4243 
    …… 
    4546#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    4647 
    47 class iqRosterQuery(iqQueryBase, Subject): 
    48     def __init__(self, JabberClient): 
    49         iqQueryBase.__init__(self, JabberClient) 
    50         Subject.__init__(self) 
    51         self._observer = Observer(self.Update, self.Bid) 
    52         self.JC().stream.AddObserver('iq', self._observer) 
    53         self.JC().SendXML('''<iq type='get'><query xmlns='jabber:iq:roster'/></iq>''') 
     48class iqRosterQuery(iqQueryBase, CategorySubject): 
     49    def __init__(self, JC, callback=None, BidValue=1): 
     50        self.OnRosterCallback = BindCallable(callback) 
     51        iqQueryBase.__init__(self, JC, self.OnRosterInfo, BidValue) 
     52        CategorySubject.__init__(self) 
     53        self.SendQuery('jabber:iq:roster') 
    5454        self.ByJID = {} 
    5555 
    56     def Bid(self, subject, **UpdateDict): 
    57         iq = UpdateDict.get('iq', None) 
    58         if iq: 
    59             bMatch = iq.type in ['result', 'error'] 
    60             if bMatch: bMatch = iq.Elements(namespace='jabber:iq:roster') and 1 or 0 
    61             return bMatch and 1 or 0 
    62         return 0 
    63      
    64     def Update(self, subject, iq): 
     56    def OnRosterInfo(self, stream, iq): 
    6557        RosterItems = getattr(iq.query[0], 'item', []) 
    6658        for each in RosterItems: 
    67             self.ByJID[JID.join(JID.split(each.jid)[:2])] = each 
     59            self.ByJID[each.jid] = each 
     60            self.UpdateObserversEx({('rosteritem', each.jid):each}) 
    6861        if RosterItems: 
    69             self.UpdateObservers(Roster=self.ByJID) 
     62            self.UpdateObservers(roster=self.ByJID) 
     63        if self.OnRosterCallback: 
     64            self.OnRosterCallback(stream, iq) 
    7065 
    71     def Get(self, JID, default=None): 
    72         return self.ByJID.get(JID.join(JID.split(JID)[:2]), default) 
     66    def Get(self, jid, default=None): 
     67        return self.ByJID.get(JID.JID(jid), default) 
    7368 

  • trunk/RBJabber/RBJabber/iqTimeResponse.py

    r66 r96  
    4343 
    4444class iqTimeResponse(iqResponseBase): 
    45     def __init__(self, JC): 
    46         iqResponseBase.__init__(self, JC) 
     45    def __init__(self, JC, BidValue=1): 
     46        iqResponseBase.__init__(self, JC, self.OnIQTimeRequest, BidValue) 
    4747        self.AnswerQuery("jabber:iq:time") 
    4848 
    49     def Update(self, subject, **UpdateDict): 
    50         iq = UpdateDict['iq'] 
     49    def OnIQTimeRequest(self, subject, iq): 
    5150        iq.to = iq.from_ 
    5251        del iq.from_ 
    …… 
    6059        strResult += '''</query></iq>''' 
    6160 
    62         self.JC().SendXML(strResult) 
     61        iq._client.SendXML(strResult) 
    6362 

  • trunk/RBJabber/RBJabber/iqVersionResponse.py

    r81 r96  
    4444 
    4545class iqVersionResponse(iqResponseBase): 
    46     def __init__(self, JC, Name, Version, Bid=1): 
    47         iqResponseBase.__init__(self, JC) 
     46    def __init__(self, JC, Name, Version, BidValue=1): 
     47        iqResponseBase.__init__(self, JC, self.OnIQVersionRequest, BidValue) 
    4848        self.AnswerQuery("jabber:iq:version") 
    4949        self.Name = Name 
    5050        self.Versio