def accept_friend_request(self, jid): if not isinstance(jid, JID): jid = JID(jid) stanza = Presence(stanza_type=ACCEPT_RESPONSES["subscribe"], to_jid=jid.bare()) self.send(stanza) self.request_add_friend(jid)
def check_presence_subscribe(self, pres): self.assertEqual(pres.from_jid, JID("[email protected]/res")) self.assertEqual(pres.to_jid, JID("*****@*****.**")) self.assertEqual(pres.stanza_type, "subscribe") self.assertEqual(pres.stanza_id, None) self.assertEqual(pres.show, None) self.assertEqual(pres.status, None)
def test_stanza_attributes(self): stanza3 = Stanza(ElementTree.XML(STANZA3)) self.assertEqual(stanza3.element_name, u"presence") self.assertEqual(stanza3.from_jid, JID(u"[email protected]/d")) self.assertEqual(stanza3.to_jid, JID(u"[email protected]/h")) self.assertEqual(stanza3.stanza_type, u"unavailable") self.assertEqual(stanza3.stanza_id, u'666')
def check_iq4(self, iq): self.assertEqual(iq.to_jid, JID("[email protected]/res")) self.assertEqual(iq.from_jid, JID("*****@*****.**")) self.assertEqual(iq.stanza_type, "result") self.assertEqual(iq.stanza_id, "2") payload = iq.get_all_payload() self.assertFalse(payload) self.assertFalse(iq.error)
def test_stanza_build(self): stanza = Stanza("presence", from_jid=JID('[email protected]/d'), to_jid=JID('[email protected]/h'), stanza_id='666', stanza_type='unavailable') self.assertTrue( xml_elements_equal(stanza.as_xml(), ElementTree.XML(STANZA3)))
def send_xmpp_message(from_jid, to_jid, txt): msg = Message(stanza_type='chat', from_jid=JID(from_jid), to_jid=JID(to_jid), subject=None, body=txt, thread=None) bot.client.send(msg)
def setUp(self): self.handlers_called = [] self.stanzas_sent = [] self.proc = StanzaProcessor() self.proc.me = JID("[email protected]/xx") self.proc.peer = JID("[email protected]/yy") self.proc.send = self.send self.proc.initiator = True
def test_verify_server(self): cert = self.load_certificate("server", True) self.assertTrue(cert.verify_server(u"server.example.org")) self.assertTrue(cert.verify_server(JID(u"server.example.org"))) self.assertFalse(cert.verify_server(u"wrong.example.org")) self.assertFalse(cert.verify_server(JID(u"wrong.example.org"))) self.assertFalse(cert.verify_server(u"example.org")) self.assertFalse(cert.verify_server(u"sub.server.example.org"))
def test_iq_result_empty(self): iq = Iq(to_jid=JID("[email protected]/res"), from_jid=JID("*****@*****.**"), stanza_type="result", stanza_id=2) self.check_iq4(iq) xml = iq.as_xml() self.check_iq4(Iq(xml))
def get_name(self, jid): if isinstance(jid, str): jid = JID(jid) else: jid = jid.bare() try: return self.roster[jid].name or hashjid(jid) except KeyError: return hashjid(jid)
def test_serialize2(self): stanza = Stanza("presence", from_jid=JID('[email protected]/d'), to_jid=JID('[email protected]/h'), stanza_id='666', stanza_type='unavailable') xml = stanza.serialize() self.assertTrue( xml_elements_equal( ElementTree.XML(xml), ElementTree.XML(STANZA3.replace(" xmlns='jabber:client'", ""))))
def test_stanza_set_custom_payload(self): stanza7 = Stanza("iq", from_jid=JID('[email protected]/d'), to_jid=JID('[email protected]/h'), stanza_id='666', stanza_type='get') payload = TestPayload(data=u"Test") stanza7.set_payload(payload) payload1 = stanza7.get_payload(TestPayload) self.assertTrue(payload1 is payload) self.assertTrue( xml_elements_equal(ElementTree.XML(STANZA7), stanza7.as_xml(), True))
def check_iq3(self, iq): self.assertEqual(iq.from_jid, JID("[email protected]/res")) self.assertEqual(iq.to_jid, JID("*****@*****.**")) self.assertEqual(iq.stanza_type, "set") self.assertEqual(iq.stanza_id, "2") payload = iq.get_all_payload() self.assertTrue(payload) self.assertEqual(payload[0].xml_element_name, "{http://pyxmpp.jajcus.net/xmlns/test}payload") self.assertTrue(len(payload[0].element) > 0) self.assertEqual(payload[0].element[0].tag, "{http://pyxmpp.jajcus.net/xmlns/test}abc") self.assertFalse(iq.error)
def send_xmpp_message(self, receivers, req_id, message): """ Formats and sends a XMPP notification with the current domain and review request being added to the template context. Returns the resulting message ID. """ logging.info("XMPP notification send message for request #%s: %s", req_id, message) host = self.extension.settings['xmpp_host'] port = self.extension.settings['xmpp_port'] timeout = self.extension.settings['xmpp_timeout'] from_jid = self.extension.settings["xmpp_sender_jid"] password = self.extension.settings["xmpp_sender_password"] use_tls = self.extension.settings["xmpp_use_tls"] tls_verify_peer = self.extension.settings["xmpp_tls_verify_peer"] if sys.version_info[0] < 3: from_jid = from_jid.decode("utf-8") password = password.decode("utf-8") message = message.decode("utf-8") if self.extension.settings["xmpp_partychat_only"]: receivers = set() rooms = self.extension.settings["xmpp_partychat"].split() if sys.version_info[0] < 3: rooms = [room.decode("utf-8") for room in rooms] receivers.update(rooms) try: from_jid = JID(from_jid) stanzas = set() for receiver in receivers: if "@" in str(receiver): receiver_jid = JID(local_or_jid=receiver) else: receiver_jid = JID(local_or_jid=receiver, domain=from_jid.domain) stanzas.add( Message(to_jid=receiver_jid, body=message, stanza_type="chat")) client = XmppClient(host, port, timeout, from_jid, password, use_tls, tls_verify_peer) client.send(req_id, stanzas) except Exception, e: logging.error( "Error sending XMPP notification for request #%s: %s", req_id, e, exc_info=1)
def test_iq_set(self): iq = Iq(from_jid=JID("[email protected]/res"), to_jid=JID("*****@*****.**"), stanza_type="set", stanza_id=2) payload = ElementTree.Element( "{http://pyxmpp.jajcus.net/xmlns/test}payload") ElementTree.SubElement(payload, "{http://pyxmpp.jajcus.net/xmlns/test}abc") payload = XMLPayload(payload) iq.add_payload(payload) self.check_iq3(iq) xml = iq.as_xml() self.check_iq3(Iq(xml))
def del_roster(self, Jid): """ 删除好友 :param Jid: 删除的jid :return: """ if isinstance(Jid, str) or isinstance(Jid, unicode): Jid = JID(Jid) if not self.is_jid_in_roster(Jid): return UserService().del_roster(self.JID.local, Jid.bare().as_string()) UserService().del_roster(Jid.local, self.JID.as_string()) self.xmpp_client.stream._send(Presence(to_jid=Jid, stanza_type='unsubscribe'))
def main(): """Parse the command-line arguments and run the tool.""" parser = argparse.ArgumentParser(description='XMPP version checker', parents=[XMPPSettings.get_arg_parser()]) parser.add_argument('source', metavar='SOURCE', help='Source JID') parser.add_argument('target', metavar='TARGET', nargs='?', help='Target JID (default: domain of SOURCE)') parser.add_argument('--debug', action='store_const', dest='log_level', const=logging.DEBUG, default=logging.INFO, help='Print debug messages') parser.add_argument('--quiet', const=logging.ERROR, action='store_const', dest='log_level', help='Print only error messages') args = parser.parse_args() settings = XMPPSettings() settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.source = args.source.decode("utf-8") source = JID(args.source) if args.target: if sys.version_info.major < 3: args.target = args.target.decode("utf-8") target = JID(args.target) else: target = JID(source.domain) logging.basicConfig(level=args.log_level) checker = VersionChecker(source, target, settings) try: checker.run() except KeyboardInterrupt: checker.disconnect()
def check_message_full(self, msg): self.assertEqual(msg.from_jid, JID("[email protected]/res")) self.assertEqual(msg.to_jid, JID("*****@*****.**")) self.assertEqual(msg.stanza_type, "normal") self.assertEqual(msg.stanza_id, "1") self.assertEqual(msg.subject, u"Subject") self.assertEqual(msg.body, u"The body") self.assertEqual(msg.thread, u"thread-id") payload = msg.get_all_payload() self.assertTrue(payload) self.assertEqual(payload[0].xml_element_name, "{http://pyxmpp.jajcus.net/xmlns/test}payload") self.assertTrue(len(payload[0].element) > 0) self.assertEqual(payload[0].element[0].tag, "{http://pyxmpp.jajcus.net/xmlns/test}abc")
def del_roster(self, Jid): """ 删除好友 :param Jid: 删除的jid :return: """ if isinstance(Jid, str) or isinstance(Jid, unicode): Jid = JID(Jid) if not self.is_jid_in_roster(Jid): return UserService().del_roster(self.JID.local, Jid.bare().as_string()) UserService().del_roster(Jid.local, self.JID.as_string()) self.xmpp_client.stream._send( Presence(to_jid=Jid, stanza_type='unsubscribe'))
def handle_roster_received(self, event): dbstatus = Logics.get_global_info('status').value if not dbstatus: status = STATUS else: status = dbstatus p = Presence(status=status) self.client.stream.send(p) ret = [x.jid.bare() for x in self.roster if x.subscription == 'both'] self.logger.info(' -- roster:{0}'.format(ret)) members = Logics.get_members() members = [m.email for m in members] [Logics.add(frm) for frm in ret if not Logics.get_one(frm)] if IMPORT: [self.invite_member(JID(m)) for m in members if JID(m) not in ret]
def check_iq5(self, iq): self.assertEqual(iq.to_jid, JID("[email protected]/res")) self.assertEqual(iq.from_jid, JID("*****@*****.**")) self.assertEqual(iq.stanza_type, "error") self.assertEqual(iq.stanza_id, "1") payload = iq.get_all_payload() self.assertTrue(payload) self.assertEqual(payload[0].xml_element_name, "{http://pyxmpp.jajcus.net/xmlns/test}payload") self.assertTrue(len(payload[0].element) > 0) self.assertEqual(payload[0].element[0].tag, "{http://pyxmpp.jajcus.net/xmlns/test}abc") error = iq.error self.assertIsInstance(error, StanzaErrorElement) self.assertEqual(error.condition_name, "bad-request")
def check_presence_full(self, pres): self.assertEqual(pres.from_jid, JID("[email protected]/res")) self.assertEqual(pres.to_jid, JID("*****@*****.**")) self.assertEqual(pres.stanza_type, None) self.assertEqual(pres.stanza_id, "1") self.assertEqual(pres.show, "away") self.assertEqual(pres.status, "The Status") self.assertEqual(pres.priority, 10) payload = pres.get_all_payload() self.assertTrue(payload) self.assertEqual(payload[0].xml_element_name, "{http://pyxmpp.jajcus.net/xmlns/test}payload") self.assertTrue(len(payload[0].element) > 0) self.assertEqual(payload[0].element[0].tag, "{http://pyxmpp.jajcus.net/xmlns/test}abc")
def test_stanza_send(self): handler = IgnoreEventHandler() route = RecordingRoute() self.stream = StreamBase(u"jabber:client", route, []) self.start_transport([handler]) self.stream.initiate(self.transport) self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.wait_short(0.25) self.wait_short(0.25) self.assertTrue(self.stream.is_connected()) self.stream.send(Message(to_jid=JID(u"*****@*****.**"), body=u"Test")) xml = self.wait(expect=re.compile(b".*(<message.*</message>)")) self.assertIsNotNone(xml) if b"xmlns" not in xml: xml = xml.replace(b"<message", b"<message xmlns='jabber:client'") element = XML(xml) stanza = Message(element) self.assertEqual(stanza.body, u"Test") self.stream.disconnect() self.server.write(STREAM_TAIL) self.server.disconnect() self.wait() self.assertEqual(route.sent, []) self.assertEqual(route.received, []) event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, DisconnectedEvent ])
def test_bind_no_resource(self): handler = AuthorizedEventHandler() handlers = [ResourceBindingHandler(), handler] processor = StanzaProcessor() processor.setup_stanza_handlers(handlers, "post-auth") self.stream = StreamBase(u"jabber:client", processor, handlers) processor.uplink = self.stream self.stream.me = JID("[email protected]") self.start_transport([handler]) self.stream.initiate(self.transport) self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.wait_short(1) self.server.write(BIND_FEATURES) req_id = self.wait( 1, expect=re.compile(br".*<iq[^>]*id=[\"']([^\"']*)[\"']")) self.assertIsNotNone(req_id) req_id = req_id.decode("utf-8") self.server.write( BIND_GENERATED_RESPONSE.format(req_id).encode("utf-8")) self.wait() self.assertFalse(self.stream.is_connected()) event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, GotFeaturesEvent, BindingResourceEvent, AuthorizedEvent, DisconnectedEvent ])
def test_bind_resource(self): handler = EventRecorder() handlers = [ResourceBindingHandler(), handler] processor = StanzaProcessor() self.start_transport(handlers) self.stream = StreamBase(u"jabber:client", processor, handlers) processor.uplink = self.stream self.stream.receive(self.transport, self.addr[0]) self.stream.set_peer_authenticated(JID("[email protected]")) processor.setup_stanza_handlers(handlers, "post-auth") self.client.write(C2S_CLIENT_STREAM_HEAD) features = self.wait( expect=re.compile(br".*<stream:features>" br"(.*<bind.*urn:ietf:params:xml:ns:xmpp-bind.*)" br"</stream:features>")) self.assertIsNotNone(features) self.client.write(BIND_PROVIDED_REQUEST) resource = self.wait(expect=re.compile( br".*<iq.*id=(?:\"42\"|'42').*>" br"<bind.*<jid>[email protected]/(.*)</jid>.*</bind>")) self.assertEqual(resource, b"Provided") self.client.write(STREAM_TAIL) self.client.disconnect() self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ AuthenticatedEvent, StreamConnectedEvent, AuthorizedEvent, DisconnectedEvent ])
def _send(self, tgt_jid, subject, body): """ 发送消息 :param tgt_jid:目的jid :param subject: 主题 :param body: 文本 :return: """ if not self.xmpp_client.stream: self.restart() self.wait_for_auth() tgt_jid = tgt_jid if isinstance(tgt_jid, JID) else JID(tgt_jid) msg = Message(to_jid=tgt_jid, body=body, subject=subject, stanza_type="normal") # _send与send的区别,send的锁有点奇怪,有时候会卡主,暂时不用锁 # def send(self, stanza): # """Write stanza to the stream. # # :Parameters: # - `stanza`: XMPP stanza to send. # :Types: # - `stanza`: `pyxmpp2.stanza.Stanza` # """ # with self.lock: # return self._send(stanza) self.xmpp_client.stream._send(msg) logger.info("XMPPClient::_send, src_jid:%s ,src_pass:%s, des_jid:%s, subject:%s, body:%s" %\ (self.JID,self.password, tgt_jid, subject, body))
def send_message(self, stanza, to, body, log=False): """ 发送消息 `stanza` - 消息节 `to` - 接收人 接收人不在线发送离线消息 `body` - 消息主体 `log` - 记录历史消息 """ if to == USER: return if log: Logics.add_history(stanza.from_jid, to, body) if Logics.is_online(to): mode = Logics.get_info(to, 'mode').value if mode == 'talk' or not mode: if isinstance(to, (str, unicode)): to = JID(to) self.logger.debug("send '{0}' to {1!r}".format(body, to)) typ = stanza.stanza_type self._stream.send(self.make_message(to, typ, body)) else: body = NOW() + ' ' + body self.logger.debug("store offline message'{0}' for {1!r}".format( body, to)) offline_message = Logics.get_info(to, 'offline_message', '').value off_msgs = offline_message.split(self.offline_split_symbol) if len(off_msgs) >= 10: offline_message = self.offline_split_symbol.join(off_msgs[-9:]) offline_message += self.offline_split_symbol + body Logics.set_info(to, 'offline_message', offline_message)
def test_request(self): payload_received = [] errors_received = [] def callback(payload): payload_received.append(payload) def error_callback(stanza): errors_received.append(stanza) processor = Processor([]) request_software_version(processor, JID("*****@*****.**"), callback, error_callback) self.assertEqual(len(processor.stanzas_sent), 1) request = processor.stanzas_sent[0] self.assertIsInstance(request, Iq) self.assertEqual(request.stanza_type, "get") payload = request.get_payload(VersionPayload) self.assertIsNone(payload.name) self.assertIsNone(payload.version) self.assertIsNone(payload.os_name) response = request.make_result_response() payload = XMLPayload(ElementTree.XML(IQ2)[0]) response.set_payload(payload) processor.uplink_receive(response) self.assertEqual(len(processor.stanzas_sent), 1) self.assertEqual(len(payload_received), 1) self.assertEqual(len(errors_received), 0) payload = payload_received[0] self.assertEqual(payload.name, "NAME") self.assertEqual(payload.version, "VERSION") self.assertEqual(payload.os_name, "OS")
def send_status(self, statustext, to=None): if to: to_jid = JID(to) p = Presence(status=statustext, to_jid=to_jid) else: p = Presence(status=statustext) self._stream.send(p)
def __init__(self): my_jid = JID(USER + '/Bot') self.my_jid = my_jid settings = XMPPSettings({ "software_name": "qxbot", "software_version": __version__, "software_os": "Linux", "tls_verify_peer": False, "starttls": True, "ipv6": False, "poll_interval": 10, }) settings["password"] = PASSWORD version_provider = VersionProvider(settings) event_queue = settings["event_queue"] self.webqq = WebQQ(QQ, event_queue) self.connected = False #self.mainloop = TornadoMainLoop(settings) self.mainloop = EpollMainLoop(settings) self.client = Client(my_jid, [self, version_provider], settings, self.mainloop) self.logger = get_logger() self.msg_dispatch = MessageDispatch(self, self.webqq, BRIDGES) self.xmpp_msg_queue = Queue.Queue()
def test_request_error(self): payload_received = [] errors_received = [] def callback(payload): payload_received.append(payload) def error_callback(stanza): errors_received.append(stanza) processor = Processor([]) request_software_version(processor, JID("*****@*****.**"), callback, error_callback) self.assertEqual(len(processor.stanzas_sent), 1) request = processor.stanzas_sent[0] self.assertIsInstance(request, Iq) self.assertEqual(request.stanza_type, "get") payload = request.get_payload(VersionPayload) self.assertIsNone(payload.name) self.assertIsNone(payload.version) self.assertIsNone(payload.os_name) response = request.make_error_response(u'service-unavailable') processor.uplink_receive(response) self.assertEqual(len(processor.stanzas_sent), 1) self.assertEqual(len(payload_received), 0) self.assertEqual(len(errors_received), 1) received = errors_received[0] self.assertIsInstance(received, Iq) self.assertEqual(received.stanza_type, "error")
def deny_friend_request(self, jid): if not isinstance(jid, JID): jid = JID(jid) stanza = Presence(stanza_type=DENY_RESPONSES["subscribe"], to_jid=jid.bare()) self.send(stanza)
def generate_presence(self, jid, stanza_type): if not isinstance(jid, JID): jid = JID(jid) return Presence(to_jid=jid.bare(), stanza_type=stanza_type)