def test_unknown_connect_code_must_lose_connection(self):
"""
A non-zero, and non-1-to-5 connect code from the handler must result in
a lost connection, and no CONNACK.
Compliance statements MQTT-3.2.2-4, MQTT-3.2.2-5
"""
h = BasicHandler(6)
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise())
for x in iterbytes(data):
p.dataReceived(x)
self.assertTrue(t.disconnecting)
self.assertEqual(t.value(), b'')
def _test_lastwill(self):
"""
FIXME: reactivate this test.
The MQTT client can set a last will message which will be published
when it disconnects.
"""
reactor, router, server_factory, session_factory = build_mqtt_server()
session, pump = connect_application_session(
server_factory,
ObservingSession,
component_config=ComponentConfig(realm=u"mqtt"))
client_transport, client_protocol, mqtt_pump = connect_mqtt_server(
server_factory)
client_transport.write(
Connect(client_id=u"testclient",
username=u"test123",
password=u"password",
will_topic=u"test",
will_message=b'{"args":["foobar"]}',
flags=ConnectFlags(clean_session=False,
username=True,
password=True,
will=True)).serialise())
mqtt_pump.flush()
# We get a CONNECT
self.assertEqual(
client_protocol.data,
ConnACK(session_present=False, return_code=0).serialise())
client_protocol.data = b""
client_transport.write(Disconnect().serialise())
mqtt_pump.flush()
pump.flush()
self.assertEqual(client_transport.disconnected, True)
# This needs to be replaced with the real deal, see https://github.com/crossbario/crossbar/issues/885
self.assertEqual(len(session.events), 1)
self.assertEqual(session.events, [{"args": [u"foobar"]}])
def test_exception_in_subscribe_drops_connection(self):
"""
Transient failures (like an exception from handler.process_subscribe)
will cause the connection it happened on to be dropped.
Compliance statement MQTT-4.8.0-2
"""
sessions = {}
class SubHandler(BasicHandler):
@inlineCallbacks
def process_subscribe(self, event):
raise Exception("boom!")
h = SubHandler()
r = Clock()
t = StringTransport()
p = MQTTServerTwistedProtocol(h, r, sessions)
cp = MQTTClientParser()
p.makeConnection(t)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise() +
Subscribe(packet_identifier=1234,
topic_requests=[SubscriptionTopicRequest(u"a", 0)
]).serialise())
with LogCapturer("trace") as logs:
for x in iterbytes(data):
p.dataReceived(x)
sent_logs = logs.get_category("MQ500")
self.assertEqual(len(sent_logs), 1)
self.assertEqual(sent_logs[0]["log_level"], LogLevel.critical)
self.assertEqual(sent_logs[0]["log_failure"].value.args[0], "boom!")
events = cp.data_received(t.value())
self.assertEqual(len(events), 1)
self.assertTrue(t.disconnecting)
# We got the error, we need to flush it so it doesn't make the test
# error
self.flushLoggedErrors()
def test_qos_0_sends_no_ack(self):
"""
When a QoS 0 Publish packet is recieved, we don't send back a PubACK.
"""
got_packets = []
class PubHandler(BasicHandler):
def process_publish_qos_0(self, event):
got_packets.append(event)
return succeed(None)
h = PubHandler()
r, t, p, cp = make_test_items(h)
pub = Publish(duplicate=False,
qos_level=0,
retain=False,
topic_name=u"foo",
packet_identifier=None,
payload=b"bar").serialise()
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise() +
pub)
with LogCapturer("trace") as logs:
for x in iterbytes(data):
p.dataReceived(x)
events = cp.data_received(t.value())
self.assertFalse(t.disconnecting)
# Just the connack, no puback.
self.assertEqual(len(events), 1)
# The publish handler should have been called
self.assertEqual(len(got_packets), 1)
self.assertEqual(got_packets[0].serialise(), pub)
# We should get a debug message saying we got the publish
messages = logs.get_category("MQ201")
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0]["publish"].serialise(), pub)
def _test_basic_publish(self):
reactor, router, server_factory, session_factory = build_mqtt_server()
session, pump = connect_application_session(
server_factory,
ObservingSession,
component_config=ComponentConfig(realm=u"mqtt"))
client_transport, client_protocol, mqtt_pump = connect_mqtt_server(
server_factory)
client_transport.write(
Connect(client_id=u"testclient",
username=u"test123",
password=u"password",
flags=ConnectFlags(clean_session=False,
username=True,
password=True)).serialise())
mqtt_pump.flush()
# We get a CONNECT
self.assertEqual(
client_protocol.data,
ConnACK(session_present=False, return_code=0).serialise())
client_protocol.data = b""
client_transport.write(
Publish(duplicate=False,
qos_level=0,
retain=False,
topic_name=u"test",
payload=b'{"kwargs": {"bar": "baz"}}').serialise())
mqtt_pump.flush()
pump.flush()
# This needs to be replaced with the real deal, see https://github.com/crossbario/crossbar/issues/885
self.assertEqual(len(session.events), 1)
self.assertEqual(session.events, [{
"args": tuple(),
"kwargs": {
u'bar': u'baz'
}
}])
def test_uninvited_pubrel(host, port):
record = [
Frame(send=True,
data=Connect(client_id=u"test_pubrel",
flags=ConnectFlags(clean_session=True))),
Frame(send=False, data=ConnACK(session_present=False, return_code=0)),
Frame(send=True, data=PubREL(packet_identifier=1234)),
Frame(send=False, data=PubCOMP(packet_identifier=1234)),
Frame(send=True, data=Disconnect()),
ConnectionLoss(),
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("uninvited_pubrel", f.success, f.reason, f.client_transcript)
def test_reserved_packet_15(host, port):
record = [
Frame(send=True,
data=Connect(client_id=u"test_reserved15",
flags=ConnectFlags(clean_session=True))),
Frame(send=False, data=ConnACK(session_present=False, return_code=0)),
Frame(
send=True,
# v pkt 15 right here
data=b"\xf0\x13\x00\x04MQTT\x04\x02\x00\x02\x00\x07test123"),
ConnectionLoss()
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("reserved_pkt15", f.success, f.reason, f.client_transcript)
def test_transport_paused_while_processing(self):
"""
The transport is paused whilst the MQTT protocol is parsing/handling
existing items.
"""
d = Deferred()
h = BasicHandler()
h.process_connect = lambda x: d
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise())
self.assertEqual(t.producerState, 'producing')
for x in iterbytes(data):
p.dataReceived(x)
self.assertEqual(t.producerState, 'paused')
d.callback((0, False))
self.assertEqual(t.producerState, 'producing')
def test_qos_2_failure_drops_connection(self):
"""
Transient failures (like an exception from
handler.process_publish_qos_2) will cause the connection it happened on
to be dropped.
Compliance statement MQTT-4.8.0-2
"""
class PubHandler(BasicHandler):
def process_publish_qos_2(self, event):
raise Exception("boom!")
h = PubHandler()
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise() +
Publish(duplicate=False,
qos_level=2,
retain=False,
topic_name=u"foo",
packet_identifier=1,
payload=b"bar").serialise())
with LogCapturer("trace") as logs:
for x in iterbytes(data):
p.dataReceived(x)
sent_logs = logs.get_category("MQ505")
self.assertEqual(len(sent_logs), 1)
self.assertEqual(sent_logs[0]["log_level"], LogLevel.critical)
self.assertEqual(sent_logs[0]["log_failure"].value.args[0], "boom!")
events = cp.data_received(t.value())
self.assertEqual(len(events), 1)
self.assertTrue(t.disconnecting)
# We got the error, we need to flush it so it doesn't make the test
# error
self.flushLoggedErrors()
def test_qos_0_queues_message(self):
"""
The WAMP layer calling send_publish will queue a message up for
sending, and send it next time it has a chance.
"""
h = BasicHandler()
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise())
for x in iterbytes(data):
p.dataReceived(x)
# Connect has happened
events = cp.data_received(t.value())
t.clear()
self.assertFalse(t.disconnecting)
self.assertIsInstance(events[0], ConnACK)
# WAMP layer calls send_publish
p.send_publish(u"hello", 0, b'some bytes', False)
# Nothing should have been sent yet, it is queued
self.assertEqual(t.value(), b'')
# Advance the clock
r.advance(0.1)
# We should now get the sent Publish
events = cp.data_received(t.value())
self.assertEqual(len(events), 1)
self.assertEqual(
events[0],
Publish(duplicate=False,
qos_level=0,
retain=False,
packet_identifier=None,
topic_name=u"hello",
payload=b"some bytes"))
def test_basic_subscribe(self):
"""
The MQTT client can subscribe to a WAMP topic and get messages.
"""
reactor, router, server_factory, session_factory = build_mqtt_server()
client_transport, client_protocol, mqtt_pump = connect_mqtt_server(server_factory)
session, pump = connect_application_session(
server_factory, ApplicationSession, component_config=ComponentConfig(realm=u"mqtt"))
client_transport.write(
Connect(client_id=u"testclient", username=u"test123", password=u"password",
flags=ConnectFlags(clean_session=False, username=True, password=True)).serialise())
client_transport.write(
Subscribe(packet_identifier=1, topic_requests=[
SubscriptionTopicRequest(topic_filter=u"com/test/wamp", max_qos=0)
]).serialise())
mqtt_pump.flush()
self.assertEqual(
client_protocol.data,
(
ConnACK(session_present=False, return_code=0).serialise() +
SubACK(packet_identifier=1, return_codes=[0]).serialise()
))
client_protocol.data = b""
session.publish(u"com.test.wamp", u"bar")
pump.flush()
reactor.advance(0.1)
mqtt_pump.flush()
self.assertEqual(
client_protocol.data,
Publish(duplicate=False, qos_level=0, retain=False,
topic_name=u"com/test/wamp",
payload=b'{"args":["bar"]}').serialise()
)
def test_non_zero_connect_code_must_have_no_present_session(self):
"""
A non-zero connect code in a CONNACK must be paired with no session
present.
Compliance statement MQTT-3.2.2-4
"""
h = BasicHandler(self.connect_code)
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise())
for x in iterbytes(data):
p.dataReceived(x)
events = cp.data_received(t.value())
self.assertEqual(len(events), 1)
self.assertEqual(attr.asdict(events[0]), {
'return_code': self.connect_code,
'session_present': False,
})
def test_unsubscription_gets_unsuback_with_same_id(self):
"""
When an unsubscription is processed, the UnsubACK has the same ID.
Unsubscriptions are always processed.
Compliance statements MQTT-3.10.4-4, MQTT-3.10.4-5, MQTT-3.12.4-1
"""
got_packets = []
class SubHandler(BasicHandler):
def process_unsubscribe(self, event):
got_packets.append(event)
return succeed(None)
h = SubHandler()
r, t, p, cp = make_test_items(h)
unsub = Unsubscribe(packet_identifier=1234,
topics=[u"foo"]).serialise()
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise() +
unsub)
for x in iterbytes(data):
p.dataReceived(x)
events = cp.data_received(t.value())
self.assertEqual(len(events), 2)
self.assertFalse(t.disconnecting)
# UnsubACK that has the same ID
self.assertIsInstance(events[1], UnsubACK)
self.assertEqual(events[1].packet_identifier, 1234)
# The unsubscribe handler should have been called
self.assertEqual(len(got_packets), 1)
self.assertEqual(got_packets[0].serialise(), unsub)
def test_got_sent_packet(self):
"""
`process_connect` on the handler will get the correct Connect packet.
"""
got_packets = []
class SubHandler(BasicHandler):
def process_connect(self_, event):
got_packets.append(event)
return succeed((0, False))
h = SubHandler()
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise())
for x in iterbytes(data):
p.dataReceived(x)
self.assertEqual(len(got_packets), 1)
self.assertEqual(got_packets[0].client_id, u"test123")
self.assertEqual(got_packets[0].serialise(), data)
def test_lose_conn_on_unimplemented_packet(self):
"""
If we get a valid, but unimplemented for that role packet (e.g. SubACK,
which we will only ever send, and getting it is a protocol violation),
we will drop the connection.
Compliance statement: MQTT-4.8.0-1
"""
sessions = {}
# This shouldn't normally happen, but just in case.
from crossbar.adapter.mqtt import protocol
protocol.server_packet_handlers[protocol.P_SUBACK] = SubACK
self.addCleanup(
lambda: protocol.server_packet_handlers.pop(protocol.P_SUBACK))
h = BasicHandler()
r = Clock()
t = StringTransport()
p = MQTTServerTwistedProtocol(h, r, sessions)
p.makeConnection(t)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise() +
SubACK(1, [1]).serialise())
with LogCapturer("trace") as logs:
for x in iterbytes(data):
p.dataReceived(x)
sent_logs = logs.get_category("MQ402")
self.assertEqual(len(sent_logs), 1)
self.assertEqual(sent_logs[0]["log_level"], LogLevel.error)
self.assertEqual(sent_logs[0]["packet_id"], "SubACK")
self.assertTrue(t.disconnecting)
def test_qos_2_resent_on_disconnect_pubcomp(self):
"""
If we send a QoS2 Publish and we did not get a PubCOMP from the client
before it disconnected, we will resend the PubREL packet if it
connects with a non-clean session.
Compliance statements: MQTT-4.4.0-1, MQTT-3.3.1-1
"""
h = BasicHandler()
r, t, p, cp = make_test_items(h)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise())
for x in iterbytes(data):
p.dataReceived(x)
# WAMP layer calls send_publish, with QoS 2
p.send_publish(u"hello", 2, b'some bytes', False)
# Advance the clock
r.advance(0.1)
# We should now get the sent Publish
expected_publish = Publish(duplicate=False,
qos_level=2,
retain=False,
packet_identifier=1,
topic_name=u"hello",
payload=b"some bytes")
events = cp.data_received(t.value())
t.clear()
self.assertEqual(len(events), 2)
self.assertEqual(events[1], expected_publish)
# We send the PubREC to this Publish
pubrec = PubREC(packet_identifier=1)
for x in iterbytes(pubrec.serialise()):
p.dataReceived(x)
# Should get a PubREL back
events = cp.data_received(t.value())
t.clear()
self.assertEqual(len(events), 1)
self.assertEqual(events[0], PubREL(packet_identifier=1))
# Disconnect the client
t.connected = False
t.loseConnection()
p.connectionLost(None)
r2, t2, p2, cp2 = make_test_items(h)
# We must NOT have a clean session
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise())
for x in iterbytes(data):
p2.dataReceived(x)
# The flushing is queued, so we'll have to spin the reactor
r2.advance(0.1)
# Should get a resent PubREL back
events = cp2.data_received(t2.value())
t2.clear()
self.assertEqual(len(events), 2)
self.assertIsInstance(events[0], ConnACK)
self.assertEqual(events[1], PubREL(packet_identifier=1))
self.assertFalse(t2.disconnecting)
# We send the PubCOMP to this PubREL
pubcomp = PubCOMP(packet_identifier=1)
for x in iterbytes(pubcomp.serialise()):
p2.dataReceived(x)
# No more packets sent to us
events = cp2.data_received(t2.value())
self.assertEqual(len(events), 0)
self.assertFalse(t2.disconnecting)
def test_clean_session_destroys_session(self):
"""
Setting the clean_session flag to True when connecting means that any
existing session for that user ID will be destroyed.
Compliance statement MQTT-3.2.2-1
"""
sessions = {}
h = BasicHandler()
r = Clock()
t = StringTransport()
p = MQTTServerTwistedProtocol(h, r, sessions)
p.makeConnection(t)
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=False)).serialise())
for x in iterbytes(data):
p.dataReceived(x)
self.assertFalse(t.disconnecting)
self.assertEqual(list(sessions.keys()), [u"test123"])
old_session = sessions[u"test123"]
# Close the connection
p.connectionLost(None)
# New session, clean_session=True
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise())
r2 = Clock()
t2 = StringTransport()
p2 = MQTTServerTwistedProtocol(h, r2, sessions)
cp2 = MQTTClientParser()
p2.makeConnection(t2)
# Send the same connect, with the same client ID
for x in iterbytes(data):
p2.dataReceived(x)
# Connection allowed
events = cp2.data_received(t2.value())
self.assertEqual(len(events), 1)
self.assertEqual(attr.asdict(events[0]), {
'return_code': 0,
'session_present': False,
})
self.assertEqual(list(sessions.keys()), [u"test123"])
new_session = sessions[u"test123"]
# Brand new session, that won't survive
self.assertIsNot(old_session, new_session)
self.assertFalse(new_session.survives)
# We close the connection, the session is destroyed
p2.connectionLost(None)
self.assertEqual(list(sessions.keys()), [])
def test_retained(self):
"""
The MQTT client can set and receive retained messages.
"""
reactor, router, server_factory, session_factory = build_mqtt_server()
client_transport, client_protocol, mqtt_pump = connect_mqtt_server(
server_factory)
client_transport.write(
Connect(client_id=u"testclient",
username=u"test123",
password=u"password",
flags=ConnectFlags(clean_session=False,
username=True,
password=True)).serialise())
client_transport.write(
Publish(duplicate=False,
qos_level=1,
retain=True,
topic_name=u"com/test/wamp",
packet_identifier=123,
payload=b'{}').serialise())
mqtt_pump.flush()
self.assertEqual(
client_protocol.data,
(ConnACK(session_present=False, return_code=0).serialise() +
PubACK(packet_identifier=123).serialise()))
client_protocol.data = b""
client_transport.write(
Subscribe(packet_identifier=1,
topic_requests=[
SubscriptionTopicRequest(
topic_filter=u"com/test/wamp", max_qos=0)
]).serialise())
mqtt_pump.flush()
self.assertEqual(
client_protocol.data,
SubACK(packet_identifier=1, return_codes=[0]).serialise())
client_protocol.data = b""
reactor.advance(0.1)
mqtt_pump.flush()
# This needs to be replaced with the real deal, see https://github.com/crossbario/crossbar/issues/885
self.assertEqual(
client_protocol.data,
Publish(duplicate=False,
qos_level=0,
retain=True,
topic_name=u"com/test/wamp",
payload=json.dumps(
{
'args': [],
'kwargs': None
}, sort_keys=True).encode('utf8')).serialise())
def test_qos_2_sends_ack(self):
"""
When a QoS 2 Publish packet is recieved, we send a PubREC with the same
packet identifier as the original Publish, wait for a PubREL, and then
send a PubCOMP.
Compliance statement MQTT-4.3.3-2
Spec part 3.4, 4.3.3
"""
got_packets = []
class PubHandler(BasicHandler):
def process_publish_qos_2(self, event):
got_packets.append(event)
return succeed(None)
h = PubHandler()
r, t, p, cp = make_test_items(h)
pub = Publish(duplicate=False,
qos_level=2,
retain=False,
topic_name=u"foo",
packet_identifier=1,
payload=b"bar").serialise()
data = (Connect(client_id=u"test123",
flags=ConnectFlags(clean_session=True)).serialise() +
pub)
with LogCapturer("trace") as logs:
for x in iterbytes(data):
p.dataReceived(x)
events = cp.data_received(t.value())
self.assertFalse(t.disconnecting)
# ConnACK + PubREC with the same packet ID
self.assertEqual(len(events), 2)
self.assertEqual(events[1], PubREC(packet_identifier=1))
# The publish handler should have been called
self.assertEqual(len(got_packets), 1)
self.assertEqual(got_packets[0].serialise(), pub)
# We should get a debug message saying we got the publish
messages = logs.get_category("MQ203")
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0]["publish"].serialise(), pub)
# Clear the client transport
t.clear()
# Now we send the PubREL
pubrel = PubREL(packet_identifier=1)
for x in iterbytes(pubrel.serialise()):
p.dataReceived(x)
events = cp.data_received(t.value())
self.assertFalse(t.disconnecting)
# We should get a PubCOMP in response
self.assertEqual(len(events), 1)
self.assertEqual(events[0], PubCOMP(packet_identifier=1))
