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 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 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 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)
