def acknowledge_delivery(self):
try:
self._ack_waiter.set_result(True)
except MachineError:
raise HBMQTTException(
'Invalid call to method acknowledge_delivery on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def packet_class(fixed_header: MQTTFixedHeader):
try:
cls = packet_dict[fixed_header.packet_type]
return cls
except KeyError:
raise HBMQTTException("Unexpected packet Type '%s'" %
fixed_header.packet_type)
def mqtt_publish(self, topic, data, qos, retain, ack_timeout=None):
"""
Sends a MQTT publish message and manages messages flows.
This methods doesn't return until the message has been acknowledged by receiver or timeout occur
:param topic: MQTT topic to publish
:param data: data to send on topic
:param qos: quality of service to use for message flow. Can be QOS_0, QOS_1 or QOS_2
:param retain: retain message flag
:param ack_timeout: acknowledge timeout. If set, this method will return a TimeOut error if the acknowledgment
is not completed before ack_timeout second
:return: ApplicationMessage used during inflight operations
"""
if qos in (QOS_1, QOS_2):
packet_id = self.session.next_packet_id
if packet_id in self.session.inflight_out:
raise HBMQTTException(
"A message with the same packet ID '%d' is already in flight"
% packet_id)
else:
packet_id = None
message = OutgoingApplicationMessage(packet_id, topic, qos, data,
retain)
# Handle message flow
if ack_timeout is not None and ack_timeout > 0:
yield from asyncio.wait_for(self._handle_message_flow(message),
ack_timeout,
loop=self._loop)
else:
yield from self._handle_message_flow(message)
return message
def sent_pubcomp(self):
try:
self.complete()
self.pubcomp_ts = datetime.now()
except MachineError:
raise HBMQTTException(
'Invalid call to method sent_pubrec on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def received_publish(self):
try:
self.publish()
self.publish_ts = datetime.now()
except MachineError:
raise HBMQTTException(
'Invalid call to method received_publish on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def received_pubrel(self):
try:
self.release()
self.pubrel_ts = datetime.now()
self._pubrel_waiter.set_result(True)
except MachineError:
raise HBMQTTException(
'Invalid call to method received_pubcomp on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def next_packet_id(self):
self._packet_id += 1
if self._packet_id > 65535:
self._packet_id = 1
while self._packet_id in self.inflight_in or self._packet_id in self.inflight_out:
self._packet_id += 1
if self._packet_id > 65535:
raise HBMQTTException("More than 65525 messages pending. No free packet ID")
return self._packet_id
def received_puback(self):
try:
self.acknowledge()
self.puback_ts = datetime.now()
self.cancel_ack_timeout()
self._ack_waiter.set_result(True)
except MachineError:
raise HBMQTTException(
'Invalid call to method received_puback on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def __init__(self, fixed: MQTTFixedHeader=None, variable_header: PacketIdVariableHeader=None):
if fixed is None:
header = MQTTFixedHeader(PUBREL, 0x02) # [MQTT-3.6.1-1]
else:
if fixed.packet_type is not PUBREL:
raise HBMQTTException("Invalid fixed packet type %s for PubrelPacket init" % fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = variable_header
self.payload = None
def received_pubrec(self):
try:
self.receive()
self.pubrec_ts = datetime.now()
self.publish_packet = None # Discard message
self.reset_ack_timeout()
except MachineError:
raise HBMQTTException(
'Invalid call to method received_pubrec on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def __init__(self, fixed: MQTTFixedHeader=None, variable_header: PacketIdVariableHeader=None):
if fixed is None:
header = MQTTFixedHeader(PUBCOMP, 0x00)
else:
if fixed.packet_type is not PUBCOMP:
raise HBMQTTException("Invalid fixed packet type %s for PubcompPacket init" % fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = variable_header
self.payload = None
def __init__(self, fixed: MQTTFixedHeader=None, variable_header: PacketIdVariableHeader=None, payload=None):
if fixed is None:
header = MQTTFixedHeader(SUBSCRIBE, 0x02) # [MQTT-3.8.1-1]
else:
if fixed.packet_type is not SUBSCRIBE:
raise HBMQTTException("Invalid fixed packet type %s for SubscribePacket init" % fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = variable_header
self.payload = payload
def retry_publish(self):
try:
self.publish()
self._ack_waiter = asyncio.Future(loop=self._loop)
self.nb_retries += 1
self.publish_ts = datetime.now()
self.start_ack_timeout()
except MachineError:
raise HBMQTTException(
'Invalid call to method retry_publish on in-flight messages with QOS=%d, state=%s'
% (self.qos, self.state))
def __init__(self, fixed: MQTTFixedHeader = None):
if fixed is None:
header = MQTTFixedHeader(PINGREQ, 0x00)
else:
if fixed.packet_type is not PINGREQ:
raise HBMQTTException(
"Invalid fixed packet type %s for PingReqPacket init" %
fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = None
self.payload = None
def __init__(self, fixed: MQTTFixedHeader = None):
if fixed is None:
header = MQTTFixedHeader(DISCONNECT, 0x00)
else:
if fixed.packet_type is not DISCONNECT:
raise HBMQTTException(
"Invalid fixed packet type %s for DisconnectPacket init" %
fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = None
self.payload = None
def __init__(self,
fixed: MQTTFixedHeader = None,
variable_header: ConnackVariableHeader = None,
payload=None):
if fixed is None:
header = MQTTFixedHeader(CONNACK, 0x00)
else:
if fixed.packet_type is not CONNACK:
raise HBMQTTException(
"Invalid fixed packet type %s for ConnackPacket init" %
fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = variable_header
self.payload = None
def _handle_message_flow(self, app_message):
"""
Handle protocol flow for incoming and outgoing messages, depending on service level and according to MQTT
spec. paragraph 4.3-Quality of Service levels and protocol flows
:param app_message: PublishMessage to handle
:return: nothing.
"""
if app_message.qos == QOS_0:
yield from self._handle_qos0_message_flow(app_message)
elif app_message.qos == QOS_1:
yield from self._handle_qos1_message_flow(app_message)
elif app_message.qos == QOS_2:
yield from self._handle_qos2_message_flow(app_message)
else:
raise HBMQTTException("Unexcepted QOS value '%d" % str(app_message.qos))
def __init__(
self,
fixed: MQTTFixedHeader = None,
vh: ConnectVariableHeader = None,
payload: ConnectPayload = None,
):
if fixed is None:
header = MQTTFixedHeader(CONNECT, 0x00)
else:
if fixed.packet_type is not CONNECT:
raise HBMQTTException(
"Invalid fixed packet type %s for ConnectPacket init" %
fixed.packet_type)
header = fixed
super().__init__(header)
self.variable_header = vh
self.payload = payload
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_qos2_message_flow(self, app_message):
"""
Handle QOS_2 application message acknowledgment
For incoming messages, this method stores the message, sends PUBREC, waits for PUBREL, initiate delivery
and send PUBCOMP
For outgoing messages, this methods sends PUBLISH, waits for PUBREC, discards messages and wait for PUBCOMP
:param app_message:
:return:
"""
assert app_message.qos == QOS_2
if app_message.direction == OUTGOING:
if app_message.pubrel_packet and app_message.pubcomp_packet:
raise HBMQTTException(
"Message '%d' has already been acknowledged" %
app_message.packet_id)
if not app_message.pubrel_packet:
# Store message
if app_message.publish_packet is not None:
# This is a retry flow, no need to store just check the message exists in session
if app_message.packet_id not in self.session.inflight_out:
raise HBMQTTException(
"Unknown inflight message '%d' in session" %
app_message.packet_id)
publish_packet = app_message.build_publish_packet(dup=True)
else:
# Store message in session
self.session.inflight_out[
app_message.packet_id] = app_message
publish_packet = app_message.build_publish_packet()
# Send PUBLISH packet
yield from self._send_packet(publish_packet)
app_message.publish_packet = publish_packet
# Wait PUBREC
if app_message.packet_id in self._pubrec_waiters:
# PUBREC waiter already exists for this packet ID
message = "Can't add PUBREC waiter, a waiter already exists for message Id '%s'" \
% app_message.packet_id
self.logger.warning(message)
raise HBMQTTException(message)
waiter = asyncio.Future(loop=self._loop)
self._pubrec_waiters[app_message.packet_id] = waiter
yield from waiter
del self._pubrec_waiters[app_message.packet_id]
app_message.pubrec_packet = waiter.result()
if not app_message.pubcomp_packet:
# Send pubrel
app_message.pubrel_packet = PubrelPacket.build(
app_message.packet_id)
yield from self._send_packet(app_message.pubrel_packet)
# Wait for PUBCOMP
waiter = asyncio.Future(loop=self._loop)
self._pubcomp_waiters[app_message.packet_id] = waiter
yield from waiter
del self._pubcomp_waiters[app_message.packet_id]
app_message.pubcomp_packet = waiter.result()
# Discard inflight message
del self.session.inflight_out[app_message.packet_id]
elif app_message.direction == INCOMING:
self.session.inflight_in[app_message.packet_id] = app_message
# Send pubrec
pubrec_packet = PubrecPacket.build(app_message.packet_id)
yield from self._send_packet(pubrec_packet)
app_message.pubrec_packet = pubrec_packet
# Wait PUBREL
if app_message.packet_id in self._pubrel_waiters and not self._pubrel_waiters[
app_message.packet_id].done():
# PUBREL waiter already exists for this packet ID
message = "A waiter already exists for message Id '%s', canceling it" \
% app_message.packet_id
self.logger.warning(message)
self._pubrel_waiters[app_message.packet_id].cancel()
try:
waiter = asyncio.Future(loop=self._loop)
self._pubrel_waiters[app_message.packet_id] = waiter
yield from waiter
del self._pubrel_waiters[app_message.packet_id]
app_message.pubrel_packet = waiter.result()
# Initiate delivery and discard message
yield from self.session.delivered_message_queue.put(
app_message)
del self.session.inflight_in[app_message.packet_id]
# Send pubcomp
pubcomp_packet = PubcompPacket.build(app_message.packet_id)
yield from self._send_packet(pubcomp_packet)
app_message.pubcomp_packet = pubcomp_packet
except asyncio.CancelledError:
self.logger.debug("Message flow cancelled")
