def makeDataElement(self): """ Returns an XML Element that can be put into a jabber:x:avatar IQ stanza. """ data = Element((None, "data")) data["mimetype"] = "image/png" data.addContent( base64.encodestring(self.getImageData()).replace("\n", "")) return data
def sendCompletedForm(self, el, sessionid=None): to = el.getAttribute('from') ID = el.getAttribute('id') ulang = utils.getLang(el) iq = Element((None, 'iq')) iq.attributes = {'to': to, 'from': config.jid, 'type': 'result'} if ID: iq.attributes['id'] = ID command = iq.addElement('command') command.attributes = { 'node': 'settings', 'xmlns': globals.COMMANDS, 'status': 'completed' } if sessionid: command.attributes['sessionid'] = sessionid else: command.attributes['sessionid'] = self.pytrans.makeMessageID() note = command.addElement('note', None, lang.get('settings_changed')) note.attributes['type'] = 'info' x = command.addElement('x') x.attributes = {'xmlns': 'jabber:x:data', 'type': 'form'} x.addElement('title', None, lang.get('command_Settings')) x.addElement('instructions', None, lang.get('settings_changed')) self.pytrans.send(iq)
def sendTune(self, to=None, fro=None, musicinfo=None, stop=False): """ send tune to user """ LogEvent(INFO) el = Element((None, "message")) el.attributes["id"] = self.pytrans.makeMessageID() if fro: el.attributes["from"] = fro e = el.addElement("event") e.attributes["xmlns"] = globals.PUBSUBEVENT items = e.addElement("items") items.attributes["node"] = globals.TUNE item = items.addElement("item") item.attributes["id"] = self.pytrans.makeMessageID() t = item.addElement("tune") t.attributes["xmlns"] = globals.TUNE if not stop: if musicinfo and len(musicinfo) > 0: for key in musicinfo: if key in ('artist', 'length', 'rating', 'source', 'title', 'track', 'uri'): value = musicinfo[key] if value: t_key = t.addElement(key) t_key.addContent(value) for res in self.pytrans.sessions[to].resourceList: # send to every resource el.attributes["to"] = to + '/' + res self.pytrans.send(el)
def _onStartElement(self, name, attrs): print '_onStartElement', name, attrs # Generate a qname tuple from the provided name. See # http://docs.python.org/library/pyexpat.html#xml.parsers.expat.ParserCreate # for an explanation of the formatting of name. qname = name.rsplit(" ", 1) if len(qname) == 1: qname = ('', name) # Process attributes for k, v in attrs.items(): if " " in k: aqname = k.rsplit(" ", 1) attrs[(aqname[0], aqname[1])] = v del attrs[k] # Construct the new element e = Element(qname, self.defaultNsStack[-1], attrs, self.localPrefixes) self.localPrefixes = {} # Document already started if self.documentStarted == 1: if self.currElem != None: self.currElem.children.append(e) e.parent = self.currElem self.currElem = e # New document else: self.documentStarted = 1 self.DocumentStartEvent(e)
def toElement(self): el = Element((None, 'actions')) if self.default: el['execute'] = self.default [el.addElement(a) for a in self.actions] return el
def _send(): mt = getToolByName(portal, "portal_membership", None) message = Element((None, "message")) message["id"] = getRandomId() message["from"] = self.xmlstream.factory.authenticator.jid.full() message["to"] = to.userhost() x = message.addElement((NS_ROSTER_X, "x")) for jid in items: if to == jid: continue member_id = users.unescapeNode(jid.user) if mt is not None and mt.getMemberInfo(member_id): info = mt.getMemberInfo(member_id) fullname = info.get("fullname", member_id).decode("utf-8") else: log.warn("Could not get user fullname: %s" % member_id) fullname = "" item = x.addElement("item") item["action"] = "add" item["jid"] = jid.userhost() item["name"] = fullname if group: item.addElement("group", content=group) self.xmlstream.send(message)
def removeListEntry(self, type, jabberID, legacyID): """ Removes a legacy ID entry from a list in the XDB, based off the type and jabberID you provide. """ if type != "roster": return xdbns = XDBNS_PREFIX + type list = self.request(jabberID, xdbns) if list == None: list = Element((None, "aimtrans")) list.attributes["xmlns"] = xdbns buddies = None for child in list.elements(): try: if child.name == "buddies": buddies = child break except AttributeError: continue if buddies == None: buddies = list.addElement("buddies") # Remove the existing element for child in buddies.elements(): try: if child.getAttribute("name") == legacyID: buddies.children.remove(child) except AttributeError: continue self.set(jabberID, xdbns, list)
def sendMood(self, to=None, fro=None, mood=None, text=None, action=None): """ send mood to user """ LogEvent(INFO) el = Element((None, "message")) el.attributes["id"] = self.pytrans.makeMessageID() if fro: el.attributes["from"] = fro e = el.addElement("event") e.attributes["xmlns"] = globals.PUBSUBEVENT items = e.addElement("items") items.attributes["node"] = globals.MOOD if action == 'retract': r = items.addElement("retract") r.attributes["id"] = self.pytrans.makeMessageID() else: item = items.addElement("item") item.attributes["id"] = self.pytrans.makeMessageID() m = item.addElement("mood") m.attributes["xmlns"] = globals.MOOD if mood: m.addElement(mood) if text: t = m.addElement("text") t.addContent(text) for res in self.pytrans.sessions[to].resourceList: # send to every resource el.attributes["to"] = to + '/' + res self.pytrans.send(el)
def toElement(self): el = Element((collab.COLLAB_NS, 'portfolio')) el.addElement('name', content=self.name) ass_el = el.addElement('assets') for a in self.assets: ass_el.addChild(a.toElement()) return el
class Device(Element): ''' classdocs ''' def __init__(self, deviceName, rootUri, feeds=None, tags=None): Element.__init__(self, (None, 'device')) self._deviceName = Element((None, 'name')) self._deviceName.addContent(deviceName) self.addChild(self._deviceName) self._rootUri = Element((None, 'rootUri')) self._rootUri.addContent(rootUri) self.addChild(self._rootUri) self._feeds = [] if feeds is not None: for f in feeds: self._feeds.append(f) self.addChild(f) self._tags = [] if tags is not None: for t in tags: tag = Tag(t) self.addChild(tag) self._tags.append(tag) def addFeed(self, feed): self._feeds.append(feed) self.addChild(feed) def addTag(self, tag): eTag = Tag(tag) self._tags.append(eTag) self.addChild(eTag)
def _send(): mt = getToolByName(portal, 'portal_membership', None) message = Element(( None, "message", )) message["id"] = getRandomId() message["from"] = self.xmlstream.factory.authenticator.jid.full() message["to"] = to.userhost() x = message.addElement((NS_ROSTER_X, 'x')) for jid in items: if to == jid: continue member_id = users.unescapeNode(jid.user) if mt is not None and mt.getMemberInfo(member_id): info = mt.getMemberInfo(member_id) fullname = info.get('fullname', member_id).decode('utf-8') else: log.warn('Could not get user fullname: %s' % member_id) fullname = '' item = x.addElement('item') item["action"] = 'add' item["jid"] = jid.userhost() item["name"] = fullname if group: item.addElement('group', content=group) self.xmlstream.send(message)
def getRandomPortfolio(min_size=10): portfolio = Element((collab.COLLAB_NS, 'portfolio')) #assets assets = portfolio.addElement('assets') no_assets = random.randrange(min_size,20) no_issuers = int(no_assets/ratio) for i in xrange(no_assets): a = assets.addElement('asset') a.addElement('id').addContent(str(i)) a.addElement('name').addContent('asset%i' % i) a.addElement('default_probability').addContent(str(float(i)/div)) #issuers issuers = portfolio.addElement('issuers') for i in xrange(no_issuers): iss = issuers.addElement('issuer') iss.addElement('id').addContent(str(i)) iss.addElement('name').addContent('issuer%i' % i) fs = iss.addElement('factors') for j in xrange(random.randrange(1, 5)): f = fs.addElement('factor') f.addElement('name').addContent('factor%i' % j) f.addElement('weight').addContent(str(float(j)/div)) #asset issuer map aimap = portfolio.addElement('asset_issuer_map') for i in xrange(no_assets): a = aimap.addElement('asset') a.addElement('id').addContent(str(i)) a.addElement('issuer').addElement('id').addContent(str(i%no_issuers)) return portfolio
def getPortfolio(): portfolio = Element((collab.COLLAB_NS, 'portfolio')) #assets assets = portfolio.addElement('assets') for i in xrange(num_assets): a = assets.addElement('asset') a.addElement('id').addContent(str(i)) a.addElement('name').addContent('asset%i' % i) a.addElement('default_probability').addContent(str(float(i)/div)) #issuers issuers = portfolio.addElement('issuers') for i in xrange(num_issuers): iss = issuers.addElement('issuer') iss.addElement('id').addContent(str(i)) iss.addElement('name').addContent('issuer%i' % i) fs = iss.addElement('factors') for j in xrange(num_factors): f = fs.addElement('factor') f.addElement('name').addContent('factor%i' % j) f.addElement('weight').addContent(str(float(j)/div)) #asset issuer map aimap = portfolio.addElement('asset_issuer_map') for i in xrange(num_assets): a = aimap.addElement('asset') a.addElement('id').addContent(str(i)) a.addElement('issuer').addElement('id').addContent(str(i%num_issuers)) return portfolio
def onIq(self, element: Element): source = JID(element.getAttribute("from")) recipient = JID(element.getAttribute("to")) identification = element.getAttribute("id") iqType = element.getAttribute("type") print("IqReceived " + source.full() + " -> " + recipient.full() + ": " + iqType) # Process component iq if recipient.full() == self.h2x.config.JID: self.componentIq(element, source, identification, iqType) return # Process user iq if self.h2x.isHangUser(recipient): self.userIq(element, source, recipient, identification, iqType) return # TODO: Can we send something like wrong request? self.__sendIqError( recipient=source.full(), sender=recipient.full(), identification=identification, errorType="cancel", condition="service-unavailable", )
def test_fromElement_bad(self): el = Element((collab.COLLAB_NS, 'wrong')) el.addElement('runs', content='100') def doIt(): p = simulation.Progress.fromElement(el) self.assertRaises(simulation.InvalidProgressError, doIt)
def test_fromElement_notTopNode(self): el = Element(('http://jabber.org/protocol/pubsub#event', 'item')) prog = el.addElement('progress', defaultUri=collab.COLLAB_NS) prog.addElement('runs', content='100') p = simulation.Progress.fromElement(el) self.assertEquals(p.runs, 100)
def toEtree(self): msg = Element(('jabber:client', 'iq')) msg['type'] = self.type msg['id'] = self.id msg['from'] = self.from_ msg['to'] = self.to if self.type == 'result': ecm_message = msg.addElement('ecm_message') ecm_message['version'] = str(AGENT_VERSION_PROTOCOL) ecm_message['core'] = str(AGENT_VERSION_CORE) ecm_message['command'] = self.command ecm_message['signature'] = self.signature result = ecm_message.addElement('result') result['retvalue'] = self.retvalue result['timed_out'] = self.timed_out result['partial'] = self.partial # compress out result.addElement('gzip_stdout').addContent(base64.b64encode(zlib.compress(self.stdout))) result.addElement('gzip_stderr').addContent(base64.b64encode(zlib.compress(self.stderr))) del ecm_message return msg
def test_fromElement_ignoresNonData(self): name = 'bender' el = Element((collab.COLLAB_NS, 'distributions')) h = el.addElement('histogram') h['name'] = name for i in xrange(10): if i%2: d_el = h.addElement('ignored') d_el['point'] = str(i) d_el['value'] = str(2*i) else: d_el = h.addElement('data') d_el['point'] = str(i) d_el['value'] = str(2*i) d = simulation.Distributions.fromElement(el) self.assertTrue(name in d.histograms) self.assertEquals(len(d.histograms), 1) hist = d.histograms[name] for i in xrange(10): if i%2: self.assertTrue(i not in hist) else: self.assertTrue(i in hist) self.assertEquals(hist[i], 2*i)
def test_fromElement(self): el = Element((collabNs, 'asset')) el.addElement('name', content='ass') el.addElement('dp', content='0.1') el.addElement('recovery', content='0.1') el.addElement('notional', content='200.0') i_el = el.addElement('issuer') i_el.addElement('name', content='iss') fs_el = i_el.addElement('factors') f1_el = fs_el.addElement('factor') f1_el.addElement('name', content='f1') f1_el.addElement('weight', content='0.1') f2_el = fs_el.addElement('factor') f2_el.addElement('name', content='f2') f2_el.addElement('weight', content='0.2') ass = portfolio.Asset.fromElement(el) self.assertEquals(ass.name, 'ass') self.assertEquals(ass.dp, 0.1) self.assertEquals(ass.recovery, 0.1) self.assertEquals(ass.notional, 200.0) i = ass.issuer self.assertEquals(i.name, 'iss') fs = i.factors self.assertEquals(len(fs), 2) self.assertTrue(checkFactor('f1', 0.1, fs)) self.assertTrue(checkFactor('f2', 0.2, fs))
def setUp(self): # Build element: # <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource"> # somecontent # <bar> # <foo> # <gar>DEF</gar> # </foo> # </bar> # somemorecontent # <bar attrib2="value2"> # <bar> # <foo/> # <gar>ABC</gar> # </bar> # <bar/> # </foo> self.e = Element(("testns", "foo")) self.e["attrib1"] = "value1" self.e["attrib3"] = "user@host/resource" self.e.addContent("somecontent") self.bar1 = self.e.addElement("bar") self.subfoo = self.bar1.addElement("foo") self.gar1 = self.subfoo.addElement("gar") self.gar1.addContent("DEF") self.e.addContent("somemorecontent") self.bar2 = self.e.addElement("bar") self.bar2["attrib2"] = "value2" self.bar3 = self.bar2.addElement("bar") self.subfoo2 = self.bar3.addElement("foo") self.gar2 = self.bar3.addElement("gar") self.gar2.addContent("ABC") self.bar4 = self.e.addElement("bar")
def gotStreamhost(host): for streamhost in streamhosts: if streamhost[1] == host: jid = streamhost[0] break else: LogEvent(WARN) return errOut() for connector in factory.connectors: # Stop any other connections try: connector.stopConnecting() except error.NotConnectingError: pass if factory.streamHostTimeout: factory.streamHostTimeout.cancel() factory.streamHostTimeout = None iq = Element((None, "iq")) iq["type"] = "result" iq["from"] = toj.full() iq["to"] = froj.full() iq["id"] = ID query = iq.addElement("query") query["xmlns"] = disco.S5B streamhost = query.addElement("streamhost-used") streamhost["jid"] = jid self.pytrans.send(iq)
def test_onGotDistribution(self): self.dm.broadcastLogs = Mock() self.dm.handleDistribution = Mock(side_effect=utils.good_side_effect('lush')) self.dm._errback = Mock(side_effect=utils.good_side_effect('err logged')) item = Element((pubsub.NS_PUBSUB_EVENT, 'item')) item['id'] = str(1) params = sim.Parameters(run_id='1', cmd='results') params_el = params.toElement() progress = sim.Progress(200) params_el.addChild(progress.toElement()) dist = sim.Distributions() hist = defaultdict(int) hist[1] = 1 hist[2] = 2 dist.combine('a', hist) params_el.addChild(dist.toElement()) item.addChild(params_el) lg = sim.Logger() d = self.dm.onGotDistribution(params, item, lg) def check(data): self.assertFalse(self.dm.broadcastLogs.called) self.assertEquals(self.dm.handleDistribution.call_count, 1) self.assertFalse(self.dm._errback.called) d.addCallback(check) self.sch.clock.pump([1,1,1]) return d
def removeListEntry(self, type, jabberID, legacyID): """ Removes a legacy ID entry from a list in the XDB, based off the type and jabberID you provide. """ if type != "roster": return xdbns = XDBNS_PREFIX+type list = self.request(jabberID, xdbns) if list == None: list = Element((None, "aimtrans")) list.attributes["xmlns"] = xdbns buddies = None for child in list.elements(): try: if child.name == "buddies": buddies = child break except AttributeError: continue if buddies == None: buddies = list.addElement("buddies") # Remove the existing element for child in buddies.elements(): try: if child.getAttribute("name") == legacyID: buddies.children.remove(child) except AttributeError: continue self.set(jabberID, xdbns, list)
def toElement(self): el = Element((collab.COLLAB_NS, 'issuer')) el.addElement('name', content=self.name) factors = el.addElement('factors') for f in self.factors: factors.addChild(f.toElement()) return el
def test_onGotStartSimulation_noPortfolio(self): run_id = '1' item = Element((pubsub.NS_PUBSUB_EVENT, 'item')) item['id'] = str(run_id) params = sim.Parameters(run_id=run_id, cmd='info') params_el = item.addChild(params.toElement()) logger = sim.Logger() self.cds.broadcastLogs = Mock(side_effect=utils.good_side_effect('done')) self.cds.broadcastResults = Mock() self.cds.simulatorFactory = MagicMock() self.cds._errback = Mock() gen = self.cds.onGotStartSimulation(params, item, logger) d = gen.next() def check(data): self.cds.broadcastLogs.assert_called_once_with(logger, params) self.assertFalse(self.cds.broadcastResults.called) self.assertFalse(self.cds.simulatorFactory.__getitem__.called) self.assertFalse(self.cds._errback.called) d.addCallback(check) self.assertRaises(StopIteration, gen.next) return d
def test_toElement(self): p = simulation.Progress(100) el = p.toElement() expected = Element((collab.COLLAB_NS, 'progress')) expected.addElement('runs', content='100') self.assertEquals(el.toXml(), expected.toXml())
def test_Issuer_fromElement_factorsButNoneInThere(self): expected = Element((collabNs, 'issuer')) expected.addElement('name', content='iss') fs_el = expected.addElement('factors') i = portfolio.Issuer.fromElement(expected) self.assertEquals(i.name, 'iss') self.assertEquals(i.factors, set())
def test_toElement(self): n = Note('bla', 'error') el = Element((None, 'note')) el['type'] = 'error' el.addContent('bla') self.assertEquals(n.toElement().toXml(), el.toXml())
def list_movies(self): request = Element((None, 'movie_list')) for movie in movies: m = request.addElement('movie') m['id_movie'] = movie.id_movie m['title'] = movie.title m['size'] = str(movie.size) self.sendObject(request)
def test_fromElement_bad(self): el = Element((None, 'note')) el['type'] = 'wrong' el.addContent('bla') n = Note.fromElement(el) self.assertEquals(n.note_type, 'warn') self.assertEquals(n.content, 'bla')
def test_fromElement_noAssets(self): el = Element((collabNs, 'portfolio')) el.addElement('name', content='port') def doIt(): p = portfolio.Portfolio.fromElement(el) self.assertRaises(portfolio.InvalidPortfolioError, doIt)
def test_fromElement(self): el = Element((None, 'note')) el['type'] = 'error' el.addContent('bla') n = Note.fromElement(el) self.assertEquals(n.note_type, 'error') self.assertEquals(n.content, 'bla')
def test_fromElement_noWeight(self): el = Element((collabNs, 'factor')) el.addElement('name', content='fac') def doIt(): f = portfolio.Factor.fromElement(el) self.assertRaises(portfolio.InvalidFactorError, doIt)
def makePhotoElement(self): """ Returns an XML Element that can be put into the vCard. """ photo = Element((None, "PHOTO")) type = photo.addElement("TYPE") type.addContent("image/png") binval = photo.addElement("BINVAL") binval.addContent(base64.encodestring(self.getImageData()).replace("\n", "")) return photo
def test_fromElement(self): el = Element((collabNs, 'factor')) el.addElement('name', content='fac') el.addElement('weight', content='0.5') f = portfolio.Factor.fromElement(el) self.assertEquals(f.name, 'fac') self.assertEquals(f.weight, 0.5)
def list_movies(self): request = Element((None, 'movie_list')) for movie in movies.get_movie_dict(): m = request.addElement('movie') m['id_movie'] = movie.get_id() m['title'] = movie.get_title() m['size'] = str(movie.get_size()) self.sendObject(request)
def successReply(self, incoming): reply = Element((None, "iq")) reply.attributes["type"] = "result" ID = incoming.getAttribute("id") if(ID): reply.attributes["id"] = ID reply.attributes["from"] = config.jid reply.attributes["to"] = incoming.getAttribute("from") self.pytrans.send(reply)
def test_fromElement_noAssetsInAssetsElement(self): el = Element((collabNs, 'portfolio')) el.addElement('name', content='port') assets_el = el.addElement('assets') p = portfolio.Portfolio.fromElement(el) self.assertEquals(p.name, 'port') self.assertEquals(p.assets, set())
def setUp(self): # Build element: # <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource"> # somecontent # <bar> # <foo> # <gar>DEF</gar> # </foo> # </bar> # somemorecontent # <bar attrib2="value2"> # <bar> # <foo/> # <gar>ABC</gar> # </bar> # <bar/> # <bar attrib4='value4' attrib5='value5'> # <foo/> # <gar>JKL</gar> # </bar> # <bar attrib4='value4' attrib5='value4'> # <foo/> # <gar>MNO</gar> # </bar> # <bar attrib4='value4' attrib5='value6'/> # </foo> self.e = Element(("testns", "foo")) self.e["attrib1"] = "value1" self.e["attrib3"] = "user@host/resource" self.e.addContent("somecontent") self.bar1 = self.e.addElement("bar") self.subfoo = self.bar1.addElement("foo") self.gar1 = self.subfoo.addElement("gar") self.gar1.addContent("DEF") self.e.addContent("somemorecontent") self.bar2 = self.e.addElement("bar") self.bar2["attrib2"] = "value2" self.bar3 = self.bar2.addElement("bar") self.subfoo2 = self.bar3.addElement("foo") self.gar2 = self.bar3.addElement("gar") self.gar2.addContent("ABC") self.bar4 = self.e.addElement("bar") self.bar5 = self.e.addElement("bar") self.bar5["attrib4"] = "value4" self.bar5["attrib5"] = "value5" self.subfoo3 = self.bar5.addElement("foo") self.gar3 = self.bar5.addElement("gar") self.gar3.addContent("JKL") self.bar6 = self.e.addElement("bar") self.bar6["attrib4"] = "value4" self.bar6["attrib5"] = "value4" self.subfoo4 = self.bar6.addElement("foo") self.gar4 = self.bar6.addElement("gar") self.gar4.addContent("MNO") self.bar7 = self.e.addElement("bar") self.bar7["attrib4"] = "value4" self.bar7["attrib5"] = "value6"
def leaveChatRoom(self, jid): if '/' not in jid: jid += '/' + self.SERVICECONFIG.JABBER_CHAT_NICK presence = Element((None, 'presence')) presence['from'] = self.jid.userhost() presence['to'] = jid presence['type'] = 'unavailable' log('sending leave: %s' % presence.toXml()) self.xmlstream.send(presence)
def makePhotoElement(self): """ Returns an XML Element that can be put into the vCard. """ photo = Element((None, "PHOTO")) type = photo.addElement("TYPE") type.addContent("image/png") binval = photo.addElement("BINVAL") binval.addContent( base64.encodestring(self.getImageData()).replace("\n", "")) return photo
def streamStarted(self, rootelem): # Create handshake hs = Element(("jabber:component:accept", "handshake")) hs.addContent(xmlstream.hashPassword(self.xmlstream.sid, self.password)) # Setup observer to watch for handshake result self.xmlstream.addOnetimeObserver("/handshake", self._handshakeEvent) self.xmlstream.send(hs)
def sendChatStateNotification(self, to, fro, state): """ Sends the user the contact's chat state status """ if self.chatStateUser: LogEvent(INFO, self.jabberID) el = Element((None, "message")) el.attributes["to"] = to el.attributes["from"] = fro x = el.addElement(state) x.attributes["xmlns"] = globals.CHATSTATES self.pytrans.send(el)
def connectionMade(self): request = Element((None, 'register_download_server')) request['host'] = self.factory.host request['port'] = str(self.factory.port) for movie in movies: m = request.addElement('movie') m['id_movie'] = movie.id_movie m['title'] = movie.title m['size'] = str(movie.size) self.sendObject(request)
def sendNickname(self, tojid=None): if not tojid: tojid = self.contactList.session.jabberID if self.nickname: el = Element((None, "message")) el.attributes["to"] = tojid el.attributes["from"] = self.jid nick = el.addElement("nick") nick.attributes["xmlns"] = globals.NICK nick.addContent(self.nickname) self.contactList.session.pytrans.send(el)
def formRegEntry(username, password): """ Returns a domish.Element representation of the data passed. This element will be written to the XDB spool file """ reginfo = Element((None, "query")) reginfo.attributes["xmlns"] = "jabber:iq:register" userEl = reginfo.addElement("username") userEl.addContent(username) passEl = reginfo.addElement("password") passEl.addContent(password) return reginfo
def testAddObserverInDispatch(self): # Test for registration of events during dispatch d = EventDispatcher() msg = Element(("ns", "message")) pres = Element(("ns", "presence")) cb = CallbackTracker2(d) d.addObserver("/message", cb.call2) d.dispatch(msg) self.assertEquals(cb.called, 0) d.dispatch(pres) self.assertEquals(cb.called, 1)
def testDispatcherResult(self): d = EventDispatcher() msg = Element(("ns", "message")) pres = Element(("ns", "presence")) cb = CallbackTracker() d.addObserver("/presence", cb.call) result = d.dispatch(msg) self.assertEquals(False, result) result = d.dispatch(pres) self.assertEquals(True, result)
def incoming_reply(q, bus, conn): chan, outbound, contact_name, self_handle_name = \ setup_incoming_tests(q, bus, conn) moar = Element((ycs.MESSAGE_NS, 'message')) moar['ninety-nine-problems'] = 'but a sauvignon blanc aint one' moar['also'] = 'my mum said hi' trollface = moar.addElement('trollface', content='problem?') call_async( q, chan, 'Reply', { 'ninety-nine-problems': 'but a sauvignon blanc aint one', 'also': 'my mum said hi' }, moar.toXml()) _, e = q.expect_many(EventPattern('dbus-return', method='Reply'), EventPattern('stream-iq', connection=outbound)) iq = e.stanza assertEquals('le-loldongs', iq['id']) assertEquals('result', iq['type']) assertEquals(self_handle_name, iq['from']) assertEquals(contact_name, iq['to']) assertEquals(1, len(iq.children)) message = iq.children[0] assertEquals('message', message.name) assertEquals(ycs.MESSAGE_NS, message.uri) assertEquals('my mum said hi', message['also']) assertEquals('but a sauvignon blanc aint one', message['ninety-nine-problems']) assertEquals('the.from.service', message['to-service']) assertEquals('the.to.service', message['from-service']) assertEquals(1, len(message.children)) trollface = message.children[0] assertEquals('trollface', trollface.name) assertEquals(1, len(trollface.children)) assertEquals('problem?', trollface.children[0]) # check we can't call anything any more call_async(q, chan, 'Fail', ycs.ERROR_TYPE_CANCEL, 'lol', 'whut', 'pear') q.expect('dbus-error', method='Fail') call_async(q, chan, 'Reply', {'lol': 'whut'}, '') q.expect('dbus-error', method='Reply') call_async(q, chan, 'Request') q.expect('dbus-error', method='Request')
def joinChatRoom(self, room): presence = Element((None, 'presence')) presence['from'] = self.jid.userhost() jid = '%s@%s/%s' % (room, self.SERVICECONFIG.JABBER_CHAT_SERVICE, self.SERVICECONFIG.JABBER_CHAT_NICK) presence['to'] = jid x = Element(('http://jabber.org/protocol/muc', 'x')) history = Element((None, 'history')) history['maxchars'] = '0' x.addChild(history) presence.addChild(x) log('sending join: %s' % presence.toXml()) self.xmlstream.send(presence)
def testOrderedXPathDispatch(self): d = EventDispatcher() cb = OrderedCallbackTracker() d.addObserver("/message/body", cb.call2) d.addObserver("/message", cb.call3, -1) d.addObserver("/message/body", cb.call1, 1) msg = Element(("ns", "message")) msg.addElement("body") d.dispatch(msg) self.assertEquals( cb.callList, [cb.call1, cb.call2, cb.call3], "Calls out of order: %s" % repr([c.__name__ for c in cb.callList]))
def requestAuthorization(self, to): request = Element((None, 'iq')) request['type'] = 'set' request['id'] = 'auth-request:%s' % to query = Element((None, 'query')) query['xmlns'] = 'jabber:iq:roster' item = Element((None, 'item')) item['jid'] = to item['name'] = to.split('@')[0] query.addChild(item) request.addChild(query) log('sending auth request: %s' % request.toXml()) self.xmlstream.send(request)
def testStuff(self): d = EventDispatcher() cb1 = CallbackTracker() cb2 = CallbackTracker() cb3 = CallbackTracker() d.addObserver("/message/body", cb1.call) d.addObserver("/message", cb1.call) d.addObserver("/presence", cb2.call) d.addObserver("//event/testevent", cb3.call) msg = Element(("ns", "message")) msg.addElement("body") pres = Element(("ns", "presence")) pres.addElement("presence") d.dispatch(msg) self.assertEquals(cb1.called, 2) self.assertEquals(cb1.obj, msg) self.assertEquals(cb2.called, 0) d.dispatch(pres) self.assertEquals(cb1.called, 2) self.assertEquals(cb2.called, 1) self.assertEquals(cb2.obj, pres) self.assertEquals(cb3.called, 0) d.dispatch(d, "//event/testevent") self.assertEquals(cb3.called, 1) self.assertEquals(cb3.obj, d) d.removeObserver("/presence", cb2.call) d.dispatch(pres) self.assertEquals(cb2.called, 1)
def sendMessage(self, to, body): """ Send a text message """ message = Element(( None, "message", )) message["id"] = getRandomId() message["from"] = self.xmlstream.factory.authenticator.jid.full() message["to"] = to.full() message["type"] = 'chat' message.addElement('body', content=body) self.xmlstream.send(message) return True
def sendRosterImport(self, jid, ptype, sub, name="", groups=[]): """ Sends a special presence packet. This will work with all clients, but clients that support roster-import will give a better user experience IMPORTANT - Only ever use this for contacts that have already been authorised on the legacy service """ x = Element((None, "x")) x.attributes["xmlns"] = disco.SUBSYNC item = x.addElement("item") item.attributes["subscription"] = sub if name: item.attributes["name"] = unicode(name) for group in groups: g = item.addElement("group") g.addContent(group) self.sendPresence(to=self.jabberID, fro=jid, ptype=ptype, payload=[x])
def componentConnected(self, xmlstream): LogEvent(INFO) self.xmlstream = xmlstream self.xmlstream.addObserver("/iq", self.iq.onIq) self.xmlstream.addObserver("/presence", self.onPresence) self.xmlstream.addObserver("/message", self.onMessage) self.xmlstream.addObserver("/bind", self.onBind) self.xmlstream.addObserver("/route", self.onRouteMessage) self.xmlstream.addObserver( "/error[@xmlns='http://etherx.jabber.org/streams']", self.streamError) if config.useXCP and config.compjid: pres = Element((None, "presence")) pres.attributes["to"] = "presence@-internal" pres.attributes["from"] = config.compjid x = pres.addElement("x") x.attributes["xmlns"] = globals.COMPPRESENCE x.attributes["xmlns:config"] = globals.CONFIG x.attributes["config:version"] = "1" x.attributes["protocol-version"] = "1.0" x.attributes["config-ns"] = legacy.url + "/component" self.send(pres) if config.useComponentBinding: LogEvent(INFO, msg="Component binding to %r" % config.jid) bind = Element((None, "bind")) bind.attributes["name"] = config.jid self.send(bind) if config.useRouteWrap: self.routewrap = 1 self.sendInvitations()
def saveLegacyList(self): contactList = self.session.legacycon.getContacts() if not contactList: return newXDB = Element((None, "query")) newXDB.attributes["xmlns"] = disco.IQROSTER for contact in contactList.contacts.values(): item = newXDB.addElement("item") item.attributes["jid"] = contact.userHandle item.attributes["subscription"] = msnlist2jabsub(contact.lists) # Backwards compat item.attributes["lists"] = str(contact.lists) self.session.pytrans.xdb.set(self.jabberID, disco.IQROSTER, newXDB) LogEvent(INFO, self.jabberID, "Finished saving list.")
def sendTypingNotification(self, to, fro, typing): """ Sends the user the contact's current typing notification status """ if self.typingUser: LogEvent(INFO, self.jabberID) el = Element((None, "message")) el.attributes["to"] = to el.attributes["from"] = fro x = el.addElement("x") x.attributes["xmlns"] = globals.XEVENT if typing: composing = x.addElement("composing") id = x.addElement("id") if self.messageIDs.has_key(fro) and self.messageIDs[fro]: id.addContent(self.messageIDs[fro]) self.pytrans.send(el)
def setSetting(self, jabberID, variable, value): """ Sets a user setting in the XDB. """ prefs = self.request(jabberID, XDBNS_PREFERENCES) if prefs == None: prefs = Element((None, "query")) prefs.attributes["xmlns"] = XDBNS_PREFERENCES # Remove the existing element for child in prefs.elements(): if child.name == variable: prefs.children.remove(child) newpref = prefs.addElement(variable) newpref.addContent(value) self.set(jabberID, XDBNS_PREFERENCES, prefs)