def server_mock(reader, writer):
try:
packet = PublishPacket.build("/topic", b"test_data", rand_packet_id(), False, QOS_1, False)
yield from packet.to_stream(writer)
puback = yield from PubackPacket.from_stream(reader)
self.assertIsNotNone(puback)
self.assertEqual(packet.packet_id, puback.packet_id)
except Exception as ae:
print(ae)
future.set_exception(ae)
def server_mock(reader, writer):
try:
packet = PublishPacket.build('/topic', b'test_data', rand_packet_id(), False, QOS_1, False)
yield from packet.to_stream(writer)
puback = yield from PubackPacket.from_stream(reader)
self.assertIsNotNone(puback)
self.assertEqual(packet.packet_id, puback.packet_id)
except Exception as ae:
print(ae)
future.set_exception(ae)
def server_mock(reader, writer):
packet = yield from PublishPacket.from_stream(reader)
try:
self.assertEqual(packet.topic_name, '/topic')
self.assertEqual(packet.qos, QOS_1)
self.assertIsNotNone(packet.packet_id)
self.assertIn(packet.packet_id, self.session.inflight_out)
self.assertIn(packet.packet_id, self.handler._puback_waiters)
puback = PubackPacket.build(packet.packet_id)
yield from puback.to_stream(writer)
except Exception as ae:
future.set_exception(ae)
async def server_mock(stream):
packet = await PublishPacket.from_stream(stream)
try:
self.assertEqual(packet.variable_header.topic_name, '/topic')
self.assertEqual(packet.qos, QOS_1)
self.assertIsNotNone(packet.packet_id)
self.assertIn(packet.packet_id, self.session.inflight_out)
self.assertIn(packet.packet_id, self.handler._puback_waiters)
puback = PubackPacket.build(packet.packet_id)
await puback.to_stream(stream)
except Exception as ae:
raise
def server_mock(reader, writer):
packet = yield from PublishPacket.from_stream(reader)
try:
self.assertEquals(packet.topic_name, "/topic")
self.assertEquals(packet.qos, QOS_1)
self.assertIsNotNone(packet.packet_id)
self.assertIn(packet.packet_id, self.session.inflight_out)
self.assertIn(packet.packet_id, self.handler._puback_waiters)
puback = PubackPacket.build(packet.packet_id)
yield from puback.to_stream(writer)
except Exception as ae:
future.set_exception(ae)
async def _handle_qos1_message_flow(self, app_message):
"""
Handle QOS_1 application message acknowledgment
For incoming messages, this method stores the message and reply with PUBACK
For outgoing messages, this methods sends PUBLISH and waits for the corresponding PUBACK
:param app_message:
:return:
"""
assert app_message.qos == QOS_1
if app_message.puback_packet:
raise HBMQTTException(
"Message '%d' has already been acknowledged" %
app_message.packet_id)
if app_message.direction == OUTGOING:
if app_message.packet_id not in self.session.inflight_out:
# Store message in session
self.session.inflight_out[app_message.packet_id] = app_message
if app_message.publish_packet is not None:
# A Publish packet has already been sent, this is a retry
publish_packet = app_message.build_publish_packet(dup=True)
else:
publish_packet = app_message.build_publish_packet()
# Wait for puback
waiter = Future()
self._puback_waiters[app_message.packet_id] = waiter
# Send PUBLISH packet
try:
await self._send_packet(publish_packet)
app_message.publish_packet = publish_packet
app_message.puback_packet = await waiter.get()
finally:
del self._puback_waiters[app_message.packet_id]
# Discard inflight message
del self.session.inflight_out[app_message.packet_id]
elif app_message.direction == INCOMING:
# Initiate delivery
self.logger.debug("Add message to delivery")
await self.session.put_message(app_message)
# Send PUBACK
puback = PubackPacket.build(app_message.packet_id)
await self._send_packet(puback)
app_message.puback_packet = puback
def _handle_qos1_message_flow(self, app_message):
"""
Handle QOS_1 application message acknowledgment
For incoming messages, this method stores the message and reply with PUBACK
For outgoing messages, this methods sends PUBLISH and waits for the corresponding PUBACK
:param app_message:
:return:
"""
assert app_message.qos == QOS_1
if app_message.puback_packet:
raise HBMQTTException("Message '%d' has already been acknowledged" % app_message.packet_id)
if app_message.direction == OUTGOING:
if app_message.packet_id not in self.session.inflight_out:
# Store message in session
self.session.inflight_out[app_message.packet_id] = app_message
if app_message.publish_packet is not None:
# A Publish packet has already been sent, this is a retry
publish_packet = app_message.build_publish_packet(dup=True)
else:
publish_packet = app_message.build_publish_packet()
# Send PUBLISH packet
yield from self._send_packet(publish_packet)
app_message.publish_packet = publish_packet
# Wait for puback
waiter = asyncio.Future(loop=self._loop)
self._puback_waiters[app_message.packet_id] = waiter
yield from waiter
del self._puback_waiters[app_message.packet_id]
app_message.puback_packet = waiter.result()
# Discard inflight message
del self.session.inflight_out[app_message.packet_id]
elif app_message.direction == INCOMING:
# Initiate delivery
self.logger.debug("Add message to delivery")
yield from self.session.delivered_message_queue.put(app_message)
# Send PUBACK
puback = PubackPacket.build(app_message.packet_id)
yield from self._send_packet(puback)
app_message.puback_packet = puback
def test_to_bytes(self):
variable_header = PacketIdVariableHeader(10)
publish = PubackPacket(variable_header=variable_header)
out = publish.to_bytes()
self.assertEqual(out, b'\x40\x02\x00\x0a')
def test_from_stream(self):
data = b'\x40\x02\x00\x0a'
stream = BufferReader(data)
message = self.loop.run_until_complete(
PubackPacket.from_stream(stream))
self.assertEqual(message.variable_header.packet_id, 10)
def test_to_bytes(self):
variable_header = PacketIdVariableHeader(10)
publish = PubackPacket(variable_header=variable_header)
out = publish.to_bytes()
self.assertEqual(out, b'\x40\x02\x00\x0a')
def test_from_stream(self):
data = b'\x40\x02\x00\x0a'
stream = asyncio.StreamReader(loop=self.loop)
stream.feed_data(data)
message = self.loop.run_until_complete(PubackPacket.from_stream(stream))
self.assertEqual(message.variable_header.packet_id, 10)
def handle_publish(self, publish_packet: PublishPacket):
incoming_message = None
packet_id = publish_packet.variable_header.packet_id
qos = publish_packet.qos
if qos == 0:
if publish_packet.dup_flag:
self.logger.warn("[MQTT-3.3.1-2] DUP flag must set to 0 for QOS 0 message. Message ignored: %s" %
repr(publish_packet))
else:
# Assign packet_id as it's needed internally
packet_id = self.session.next_packet_id
publish_packet.variable_header.packet_id = packet_id
incoming_message = IncomingInFlightMessage(publish_packet,
qos,
self.session.publish_retry_delay,
self._loop)
incoming_message.received_publish()
self.session.incoming_msg[packet_id] = incoming_message
yield from self.session.delivered_message_queue.put(packet_id)
else:
# Check if publish is a retry
if packet_id in self.session.incoming_msg:
incoming_message = self.session.incoming_msg[packet_id]
else:
incoming_message = IncomingInFlightMessage(publish_packet,
qos,
self.session.publish_retry_delay,
self._loop)
self.session.incoming_msg[packet_id] = incoming_message
incoming_message.publish()
if qos == 1:
# Initiate delivery
yield from self.session.delivered_message_queue.put(packet_id)
ack = yield from incoming_message.wait_acknowledge()
if ack:
# Send PUBACK
puback = PubackPacket.build(packet_id)
yield from self.outgoing_queue.put(puback)
#Discard message
del self.session.incoming_msg[packet_id]
self.logger.debug("Discarded incoming message %d" % packet_id)
else:
raise HBMQTTException("Something wrong, ack is False")
if qos == 2:
# Send PUBREC
pubrec = PubrecPacket.build(packet_id)
yield from self.outgoing_queue.put(pubrec)
incoming_message.sent_pubrec()
# Wait for pubrel
ack = yield from incoming_message.wait_pubrel()
if ack:
# Initiate delivery
yield from self.session.delivered_message_queue.put(packet_id)
else:
raise HBMQTTException("Something wrong, ack is False")
ack = yield from incoming_message.wait_acknowledge()
if ack:
# Send PUBCOMP
pubcomp = PubcompPacket.build(packet_id)
yield from self.outgoing_queue.put(pubcomp)
incoming_message.sent_pubcomp()
#Discard message
del self.session.incoming_msg[packet_id]
self.logger.debug("Discarded incoming message %d" % packet_id)
else:
raise HBMQTTException("Something wrong, ack is False")
def handle_publish(self, publish_packet: PublishPacket):
incoming_message = None
packet_id = publish_packet.variable_header.packet_id
qos = publish_packet.qos
if qos == 0:
if publish_packet.dup_flag:
self.logger.warn(
"[MQTT-3.3.1-2] DUP flag must set to 0 for QOS 0 message. Message ignored: %s"
% repr(publish_packet))
else:
# Assign packet_id as it's needed internally
packet_id = self.session.next_packet_id
publish_packet.variable_header.packet_id = packet_id
incoming_message = IncomingInFlightMessage(
publish_packet, qos, self.session.publish_retry_delay,
self._loop)
incoming_message.received_publish()
self.session.incoming_msg[packet_id] = incoming_message
yield from self.session.delivered_message_queue.put(packet_id)
else:
# Check if publish is a retry
if packet_id in self.session.incoming_msg:
incoming_message = self.session.incoming_msg[packet_id]
else:
incoming_message = IncomingInFlightMessage(
publish_packet, qos, self.session.publish_retry_delay,
self._loop)
self.session.incoming_msg[packet_id] = incoming_message
incoming_message.publish()
if qos == 1:
# Initiate delivery
yield from self.session.delivered_message_queue.put(packet_id)
ack = yield from incoming_message.wait_acknowledge()
if ack:
# Send PUBACK
puback = PubackPacket.build(packet_id)
yield from self.outgoing_queue.put(puback)
#Discard message
del self.session.incoming_msg[packet_id]
self.logger.debug("Discarded incoming message %d" %
packet_id)
else:
raise HBMQTTException("Something wrong, ack is False")
if qos == 2:
# Send PUBREC
pubrec = PubrecPacket.build(packet_id)
yield from self.outgoing_queue.put(pubrec)
incoming_message.sent_pubrec()
# Wait for pubrel
ack = yield from incoming_message.wait_pubrel()
if ack:
# Initiate delivery
yield from self.session.delivered_message_queue.put(
packet_id)
else:
raise HBMQTTException("Something wrong, ack is False")
ack = yield from incoming_message.wait_acknowledge()
if ack:
# Send PUBCOMP
pubcomp = PubcompPacket.build(packet_id)
yield from self.outgoing_queue.put(pubcomp)
incoming_message.sent_pubcomp()
#Discard message
del self.session.incoming_msg[packet_id]
self.logger.debug("Discarded incoming message %d" %
packet_id)
else:
raise HBMQTTException("Something wrong, ack is False")
def test_from_stream(self):
data = b'\x40\x02\x00\x0a'
stream = BufferReader(data)
message = self.loop.run_until_complete(PubackPacket.from_stream(stream))
self.assertEqual(message.variable_header.packet_id, 10)
