2978 lines
110 KiB
Python
2978 lines
110 KiB
Python
|
# Copyright (c) 2012-2014 Roger Light <roger@atchoo.org>
|
||
|
|
#
|
||
|
|
# All rights reserved. This program and the accompanying materials
|
||
|
|
# are made available under the terms of the Eclipse Public License v1.0
|
||
|
|
# and Eclipse Distribution License v1.0 which accompany this distribution.
|
||
|
|
#
|
||
|
|
# The Eclipse Public License is available at
|
||
|
|
# http://www.eclipse.org/legal/epl-v10.html
|
||
|
|
# and the Eclipse Distribution License is available at
|
||
|
|
# http://www.eclipse.org/org/documents/edl-v10.php.
|
||
|
|
#
|
||
|
|
# Contributors:
|
||
|
|
# Roger Light - initial API and implementation
|
||
|
|
|
||
|
|
"""
|
||
|
|
This is an MQTT v3.1 client module. MQTT is a lightweight pub/sub messaging
|
||
|
|
protocol that is easy to implement and suitable for low powered devices.
|
||
|
|
"""
|
||
|
|
import collections
|
||
|
|
import errno
|
||
|
|
import platform
|
||
|
|
import random
|
||
|
|
import select
|
||
|
|
import socket
|
||
|
|
|
||
|
|
try:
|
||
|
|
import ssl
|
||
|
|
except ImportError:
|
||
|
|
ssl = None
|
||
|
|
|
||
|
|
import struct
|
||
|
|
import sys
|
||
|
|
import threading
|
||
|
|
|
||
|
|
import time
|
||
|
|
import uuid
|
||
|
|
import base64
|
||
|
|
import string
|
||
|
|
import hashlib
|
||
|
|
import logging
|
||
|
|
|
||
|
|
try:
|
||
|
|
# Use monotonic clock if available
|
||
|
|
time_func = time.monotonic
|
||
|
|
except AttributeError:
|
||
|
|
time_func = time.time
|
||
|
|
|
||
|
|
try:
|
||
|
|
import dns.resolver
|
||
|
|
except ImportError:
|
||
|
|
HAVE_DNS = False
|
||
|
|
else:
|
||
|
|
HAVE_DNS = True
|
||
|
|
|
||
|
|
from .matcher import MQTTMatcher
|
||
|
|
|
||
|
|
if platform.system() == 'Windows':
|
||
|
|
EAGAIN = errno.WSAEWOULDBLOCK
|
||
|
|
else:
|
||
|
|
EAGAIN = errno.EAGAIN
|
||
|
|
|
||
|
|
MQTTv31 = 3
|
||
|
|
MQTTv311 = 4
|
||
|
|
|
||
|
|
if sys.version_info[0] >= 3:
|
||
|
|
# define some alias for python2 compatibility
|
||
|
|
unicode = str
|
||
|
|
basestring = str
|
||
|
|
|
||
|
|
# Message types
|
||
|
|
CONNECT = 0x10
|
||
|
|
CONNACK = 0x20
|
||
|
|
PUBLISH = 0x30
|
||
|
|
PUBACK = 0x40
|
||
|
|
PUBREC = 0x50
|
||
|
|
PUBREL = 0x60
|
||
|
|
PUBCOMP = 0x70
|
||
|
|
SUBSCRIBE = 0x80
|
||
|
|
SUBACK = 0x90
|
||
|
|
UNSUBSCRIBE = 0xA0
|
||
|
|
UNSUBACK = 0xB0
|
||
|
|
PINGREQ = 0xC0
|
||
|
|
PINGRESP = 0xD0
|
||
|
|
DISCONNECT = 0xE0
|
||
|
|
|
||
|
|
# Log levels
|
||
|
|
MQTT_LOG_INFO = 0x01
|
||
|
|
MQTT_LOG_NOTICE = 0x02
|
||
|
|
MQTT_LOG_WARNING = 0x04
|
||
|
|
MQTT_LOG_ERR = 0x08
|
||
|
|
MQTT_LOG_DEBUG = 0x10
|
||
|
|
LOGGING_LEVEL = {
|
||
|
|
MQTT_LOG_DEBUG: logging.DEBUG,
|
||
|
|
MQTT_LOG_INFO: logging.INFO,
|
||
|
|
MQTT_LOG_NOTICE: logging.INFO, # This has no direct equivalent level
|
||
|
|
MQTT_LOG_WARNING: logging.WARNING,
|
||
|
|
MQTT_LOG_ERR: logging.ERROR,
|
||
|
|
}
|
||
|
|
|
||
|
|
# CONNACK codes
|
||
|
|
CONNACK_ACCEPTED = 0
|
||
|
|
CONNACK_REFUSED_PROTOCOL_VERSION = 1
|
||
|
|
CONNACK_REFUSED_IDENTIFIER_REJECTED = 2
|
||
|
|
CONNACK_REFUSED_SERVER_UNAVAILABLE = 3
|
||
|
|
CONNACK_REFUSED_BAD_USERNAME_PASSWORD = 4
|
||
|
|
CONNACK_REFUSED_NOT_AUTHORIZED = 5
|
||
|
|
|
||
|
|
# Connection state
|
||
|
|
mqtt_cs_new = 0
|
||
|
|
mqtt_cs_connected = 1
|
||
|
|
mqtt_cs_disconnecting = 2
|
||
|
|
mqtt_cs_connect_async = 3
|
||
|
|
|
||
|
|
# Message state
|
||
|
|
mqtt_ms_invalid = 0
|
||
|
|
mqtt_ms_publish = 1
|
||
|
|
mqtt_ms_wait_for_puback = 2
|
||
|
|
mqtt_ms_wait_for_pubrec = 3
|
||
|
|
mqtt_ms_resend_pubrel = 4
|
||
|
|
mqtt_ms_wait_for_pubrel = 5
|
||
|
|
mqtt_ms_resend_pubcomp = 6
|
||
|
|
mqtt_ms_wait_for_pubcomp = 7
|
||
|
|
mqtt_ms_send_pubrec = 8
|
||
|
|
mqtt_ms_queued = 9
|
||
|
|
|
||
|
|
# Error values
|
||
|
|
MQTT_ERR_AGAIN = -1
|
||
|
|
MQTT_ERR_SUCCESS = 0
|
||
|
|
MQTT_ERR_NOMEM = 1
|
||
|
|
MQTT_ERR_PROTOCOL = 2
|
||
|
|
MQTT_ERR_INVAL = 3
|
||
|
|
MQTT_ERR_NO_CONN = 4
|
||
|
|
MQTT_ERR_CONN_REFUSED = 5
|
||
|
|
MQTT_ERR_NOT_FOUND = 6
|
||
|
|
MQTT_ERR_CONN_LOST = 7
|
||
|
|
MQTT_ERR_TLS = 8
|
||
|
|
MQTT_ERR_PAYLOAD_SIZE = 9
|
||
|
|
MQTT_ERR_NOT_SUPPORTED = 10
|
||
|
|
MQTT_ERR_AUTH = 11
|
||
|
|
MQTT_ERR_ACL_DENIED = 12
|
||
|
|
MQTT_ERR_UNKNOWN = 13
|
||
|
|
MQTT_ERR_ERRNO = 14
|
||
|
|
MQTT_ERR_QUEUE_SIZE = 15
|
||
|
|
|
||
|
|
sockpair_data = b"0"
|
||
|
|
|
||
|
|
|
||
|
|
class WebsocketConnectionError(ValueError):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
def error_string(mqtt_errno):
|
||
|
|
"""Return the error string associated with an mqtt error number."""
|
||
|
|
if mqtt_errno == MQTT_ERR_SUCCESS:
|
||
|
|
return "No error."
|
||
|
|
elif mqtt_errno == MQTT_ERR_NOMEM:
|
||
|
|
return "Out of memory."
|
||
|
|
elif mqtt_errno == MQTT_ERR_PROTOCOL:
|
||
|
|
return "A network protocol error occurred when communicating with the broker."
|
||
|
|
elif mqtt_errno == MQTT_ERR_INVAL:
|
||
|
|
return "Invalid function arguments provided."
|
||
|
|
elif mqtt_errno == MQTT_ERR_NO_CONN:
|
||
|
|
return "The client is not currently connected."
|
||
|
|
elif mqtt_errno == MQTT_ERR_CONN_REFUSED:
|
||
|
|
return "The connection was refused."
|
||
|
|
elif mqtt_errno == MQTT_ERR_NOT_FOUND:
|
||
|
|
return "Message not found (internal error)."
|
||
|
|
elif mqtt_errno == MQTT_ERR_CONN_LOST:
|
||
|
|
return "The connection was lost."
|
||
|
|
elif mqtt_errno == MQTT_ERR_TLS:
|
||
|
|
return "A TLS error occurred."
|
||
|
|
elif mqtt_errno == MQTT_ERR_PAYLOAD_SIZE:
|
||
|
|
return "Payload too large."
|
||
|
|
elif mqtt_errno == MQTT_ERR_NOT_SUPPORTED:
|
||
|
|
return "This feature is not supported."
|
||
|
|
elif mqtt_errno == MQTT_ERR_AUTH:
|
||
|
|
return "Authorisation failed."
|
||
|
|
elif mqtt_errno == MQTT_ERR_ACL_DENIED:
|
||
|
|
return "Access denied by ACL."
|
||
|
|
elif mqtt_errno == MQTT_ERR_UNKNOWN:
|
||
|
|
return "Unknown error."
|
||
|
|
elif mqtt_errno == MQTT_ERR_ERRNO:
|
||
|
|
return "Error defined by errno."
|
||
|
|
else:
|
||
|
|
return "Unknown error."
|
||
|
|
|
||
|
|
|
||
|
|
def connack_string(connack_code):
|
||
|
|
"""Return the string associated with a CONNACK result."""
|
||
|
|
if connack_code == CONNACK_ACCEPTED:
|
||
|
|
return "Connection Accepted."
|
||
|
|
elif connack_code == CONNACK_REFUSED_PROTOCOL_VERSION:
|
||
|
|
return "Connection Refused: unacceptable protocol version."
|
||
|
|
elif connack_code == CONNACK_REFUSED_IDENTIFIER_REJECTED:
|
||
|
|
return "Connection Refused: identifier rejected."
|
||
|
|
elif connack_code == CONNACK_REFUSED_SERVER_UNAVAILABLE:
|
||
|
|
return "Connection Refused: broker unavailable."
|
||
|
|
elif connack_code == CONNACK_REFUSED_BAD_USERNAME_PASSWORD:
|
||
|
|
return "Connection Refused: bad user name or password."
|
||
|
|
elif connack_code == CONNACK_REFUSED_NOT_AUTHORIZED:
|
||
|
|
return "Connection Refused: not authorised."
|
||
|
|
else:
|
||
|
|
return "Connection Refused: unknown reason."
|
||
|
|
|
||
|
|
|
||
|
|
def base62(num, base=string.digits + string.ascii_letters, padding=1):
|
||
|
|
"""Convert a number to base-62 representation."""
|
||
|
|
assert num >= 0
|
||
|
|
digits = []
|
||
|
|
while num:
|
||
|
|
num, rest = divmod(num, 62)
|
||
|
|
digits.append(base[rest])
|
||
|
|
digits.extend(base[0] for _ in range(len(digits), padding))
|
||
|
|
return ''.join(reversed(digits))
|
||
|
|
|
||
|
|
|
||
|
|
def topic_matches_sub(sub, topic):
|
||
|
|
"""Check whether a topic matches a subscription.
|
||
|
|
|
||
|
|
For example:
|
||
|
|
|
||
|
|
foo/bar would match the subscription foo/# or +/bar
|
||
|
|
non/matching would not match the subscription non/+/+
|
||
|
|
"""
|
||
|
|
matcher = MQTTMatcher()
|
||
|
|
matcher[sub] = True
|
||
|
|
try:
|
||
|
|
next(matcher.iter_match(topic))
|
||
|
|
return True
|
||
|
|
except StopIteration:
|
||
|
|
return False
|
||
|
|
|
||
|
|
|
||
|
|
def _socketpair_compat():
|
||
|
|
"""TCP/IP socketpair including Windows support"""
|
||
|
|
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
|
||
|
|
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||
|
|
listensock.bind(("127.0.0.1", 0))
|
||
|
|
listensock.listen(1)
|
||
|
|
|
||
|
|
iface, port = listensock.getsockname()
|
||
|
|
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
|
||
|
|
sock1.setblocking(0)
|
||
|
|
try:
|
||
|
|
sock1.connect(("127.0.0.1", port))
|
||
|
|
except socket.error as err:
|
||
|
|
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
|
||
|
|
raise
|
||
|
|
sock2, address = listensock.accept()
|
||
|
|
sock2.setblocking(0)
|
||
|
|
listensock.close()
|
||
|
|
return (sock1, sock2)
|
||
|
|
|
||
|
|
|
||
|
|
class MQTTMessageInfo(object):
|
||
|
|
"""This is a class returned from Client.publish() and can be used to find
|
||
|
|
out the mid of the message that was published, and to determine whether the
|
||
|
|
message has been published, and/or wait until it is published.
|
||
|
|
"""
|
||
|
|
|
||
|
|
__slots__ = 'mid', '_published', '_condition', 'rc', '_iterpos'
|
||
|
|
|
||
|
|
def __init__(self, mid):
|
||
|
|
self.mid = mid
|
||
|
|
self._published = False
|
||
|
|
self._condition = threading.Condition()
|
||
|
|
self.rc = 0
|
||
|
|
self._iterpos = 0
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
return str((self.rc, self.mid))
|
||
|
|
|
||
|
|
def __iter__(self):
|
||
|
|
self._iterpos = 0
|
||
|
|
return self
|
||
|
|
|
||
|
|
def __next__(self):
|
||
|
|
return self.next()
|
||
|
|
|
||
|
|
def next(self):
|
||
|
|
if self._iterpos == 0:
|
||
|
|
self._iterpos = 1
|
||
|
|
return self.rc
|
||
|
|
elif self._iterpos == 1:
|
||
|
|
self._iterpos = 2
|
||
|
|
return self.mid
|
||
|
|
else:
|
||
|
|
raise StopIteration
|
||
|
|
|
||
|
|
def __getitem__(self, index):
|
||
|
|
if index == 0:
|
||
|
|
return self.rc
|
||
|
|
elif index == 1:
|
||
|
|
return self.mid
|
||
|
|
else:
|
||
|
|
raise IndexError("index out of range")
|
||
|
|
|
||
|
|
def _set_as_published(self):
|
||
|
|
with self._condition:
|
||
|
|
self._published = True
|
||
|
|
self._condition.notify()
|
||
|
|
|
||
|
|
def wait_for_publish(self):
|
||
|
|
"""Block until the message associated with this object is published."""
|
||
|
|
if self.rc == MQTT_ERR_QUEUE_SIZE:
|
||
|
|
raise ValueError('Message is not queued due to ERR_QUEUE_SIZE')
|
||
|
|
with self._condition:
|
||
|
|
while not self._published:
|
||
|
|
self._condition.wait()
|
||
|
|
|
||
|
|
def is_published(self):
|
||
|
|
"""Returns True if the message associated with this object has been
|
||
|
|
published, else returns False."""
|
||
|
|
if self.rc == MQTT_ERR_QUEUE_SIZE:
|
||
|
|
raise ValueError('Message is not queued due to ERR_QUEUE_SIZE')
|
||
|
|
with self._condition:
|
||
|
|
return self._published
|
||
|
|
|
||
|
|
|
||
|
|
class MQTTMessage(object):
|
||
|
|
""" This is a class that describes an incoming or outgoing message. It is
|
||
|
|
passed to the on_message callback as the message parameter.
|
||
|
|
|
||
|
|
Members:
|
||
|
|
|
||
|
|
topic : String/bytes. topic that the message was published on.
|
||
|
|
payload : String/bytes the message payload.
|
||
|
|
qos : Integer. The message Quality of Service 0, 1 or 2.
|
||
|
|
retain : Boolean. If true, the message is a retained message and not fresh.
|
||
|
|
mid : Integer. The message id.
|
||
|
|
|
||
|
|
On Python 3, topic must be bytes.
|
||
|
|
"""
|
||
|
|
|
||
|
|
__slots__ = 'timestamp', 'state', 'dup', 'mid', '_topic', 'payload', 'qos', 'retain', 'info'
|
||
|
|
|
||
|
|
def __init__(self, mid=0, topic=b""):
|
||
|
|
self.timestamp = 0
|
||
|
|
self.state = mqtt_ms_invalid
|
||
|
|
self.dup = False
|
||
|
|
self.mid = mid
|
||
|
|
self._topic = topic
|
||
|
|
self.payload = b""
|
||
|
|
self.qos = 0
|
||
|
|
self.retain = False
|
||
|
|
self.info = MQTTMessageInfo(mid)
|
||
|
|
|
||
|
|
def __eq__(self, other):
|
||
|
|
"""Override the default Equals behavior"""
|
||
|
|
if isinstance(other, self.__class__):
|
||
|
|
return self.mid == other.mid
|
||
|
|
return False
|
||
|
|
|
||
|
|
def __ne__(self, other):
|
||
|
|
"""Define a non-equality test"""
|
||
|
|
return not self.__eq__(other)
|
||
|
|
|
||
|
|
@property
|
||
|
|
def topic(self):
|
||
|
|
return self._topic.decode('utf-8')
|
||
|
|
|
||
|
|
@topic.setter
|
||
|
|
def topic(self, value):
|
||
|
|
self._topic = value
|
||
|
|
|
||
|
|
|
||
|
|
class Client(object):
|
||
|
|
"""MQTT version 3.1/3.1.1 client class.
|
||
|
|
|
||
|
|
This is the main class for use communicating with an MQTT broker.
|
||
|
|
|
||
|
|
General usage flow:
|
||
|
|
|
||
|
|
* Use connect()/connect_async() to connect to a broker
|
||
|
|
* Call loop() frequently to maintain network traffic flow with the broker
|
||
|
|
* Or use loop_start() to set a thread running to call loop() for you.
|
||
|
|
* Or use loop_forever() to handle calling loop() for you in a blocking
|
||
|
|
* function.
|
||
|
|
* Use subscribe() to subscribe to a topic and receive messages
|
||
|
|
* Use publish() to send messages
|
||
|
|
* Use disconnect() to disconnect from the broker
|
||
|
|
|
||
|
|
Data returned from the broker is made available with the use of callback
|
||
|
|
functions as described below.
|
||
|
|
|
||
|
|
Callbacks
|
||
|
|
=========
|
||
|
|
|
||
|
|
A number of callback functions are available to receive data back from the
|
||
|
|
broker. To use a callback, define a function and then assign it to the
|
||
|
|
client:
|
||
|
|
|
||
|
|
def on_connect(client, userdata, flags, rc):
|
||
|
|
print("Connection returned " + str(rc))
|
||
|
|
|
||
|
|
client.on_connect = on_connect
|
||
|
|
|
||
|
|
All of the callbacks as described below have a "client" and an "userdata"
|
||
|
|
argument. "client" is the Client instance that is calling the callback.
|
||
|
|
"userdata" is user data of any type and can be set when creating a new client
|
||
|
|
instance or with user_data_set(userdata).
|
||
|
|
|
||
|
|
The callbacks:
|
||
|
|
|
||
|
|
on_connect(client, userdata, flags, rc): called when the broker responds to our connection
|
||
|
|
request.
|
||
|
|
flags is a dict that contains response flags from the broker:
|
||
|
|
flags['session present'] - this flag is useful for clients that are
|
||
|
|
using clean session set to 0 only. If a client with clean
|
||
|
|
session=0, that reconnects to a broker that it has previously
|
||
|
|
connected to, this flag indicates whether the broker still has the
|
||
|
|
session information for the client. If 1, the session still exists.
|
||
|
|
The value of rc determines success or not:
|
||
|
|
0: Connection successful
|
||
|
|
1: Connection refused - incorrect protocol version
|
||
|
|
2: Connection refused - invalid client identifier
|
||
|
|
3: Connection refused - server unavailable
|
||
|
|
4: Connection refused - bad username or password
|
||
|
|
5: Connection refused - not authorised
|
||
|
|
6-255: Currently unused.
|
||
|
|
|
||
|
|
on_disconnect(client, userdata, rc): called when the client disconnects from the broker.
|
||
|
|
The rc parameter indicates the disconnection state. If MQTT_ERR_SUCCESS
|
||
|
|
(0), the callback was called in response to a disconnect() call. If any
|
||
|
|
other value the disconnection was unexpected, such as might be caused by
|
||
|
|
a network error.
|
||
|
|
|
||
|
|
on_message(client, userdata, message): called when a message has been received on a
|
||
|
|
topic that the client subscribes to. The message variable is a
|
||
|
|
MQTTMessage that describes all of the message parameters.
|
||
|
|
|
||
|
|
on_publish(client, userdata, mid): called when a message that was to be sent using the
|
||
|
|
publish() call has completed transmission to the broker. For messages
|
||
|
|
with QoS levels 1 and 2, this means that the appropriate handshakes have
|
||
|
|
completed. For QoS 0, this simply means that the message has left the
|
||
|
|
client. The mid variable matches the mid variable returned from the
|
||
|
|
corresponding publish() call, to allow outgoing messages to be tracked.
|
||
|
|
This callback is important because even if the publish() call returns
|
||
|
|
success, it does not always mean that the message has been sent.
|
||
|
|
|
||
|
|
on_subscribe(client, userdata, mid, granted_qos): called when the broker responds to a
|
||
|
|
subscribe request. The mid variable matches the mid variable returned
|
||
|
|
from the corresponding subscribe() call. The granted_qos variable is a
|
||
|
|
list of integers that give the QoS level the broker has granted for each
|
||
|
|
of the different subscription requests.
|
||
|
|
|
||
|
|
on_unsubscribe(client, userdata, mid): called when the broker responds to an unsubscribe
|
||
|
|
request. The mid variable matches the mid variable returned from the
|
||
|
|
corresponding unsubscribe() call.
|
||
|
|
|
||
|
|
on_log(client, userdata, level, buf): called when the client has log information. Define
|
||
|
|
to allow debugging. The level variable gives the severity of the message
|
||
|
|
and will be one of MQTT_LOG_INFO, MQTT_LOG_NOTICE, MQTT_LOG_WARNING,
|
||
|
|
MQTT_LOG_ERR, and MQTT_LOG_DEBUG. The message itself is in buf.
|
||
|
|
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self, client_id="", clean_session=True, userdata=None,
|
||
|
|
protocol=MQTTv311, transport="tcp"):
|
||
|
|
"""client_id is the unique client id string used when connecting to the
|
||
|
|
broker. If client_id is zero length or None, then the behaviour is
|
||
|
|
defined by which protocol version is in use. If using MQTT v3.1.1, then
|
||
|
|
a zero length client id will be sent to the broker and the broker will
|
||
|
|
generate a random for the client. If using MQTT v3.1 then an id will be
|
||
|
|
randomly generated. In both cases, clean_session must be True. If this
|
||
|
|
is not the case a ValueError will be raised.
|
||
|
|
|
||
|
|
clean_session is a boolean that determines the client type. If True,
|
||
|
|
the broker will remove all information about this client when it
|
||
|
|
disconnects. If False, the client is a persistent client and
|
||
|
|
subscription information and queued messages will be retained when the
|
||
|
|
client disconnects.
|
||
|
|
Note that a client will never discard its own outgoing messages on
|
||
|
|
disconnect. Calling connect() or reconnect() will cause the messages to
|
||
|
|
be resent. Use reinitialise() to reset a client to its original state.
|
||
|
|
|
||
|
|
userdata is user defined data of any type that is passed as the "userdata"
|
||
|
|
parameter to callbacks. It may be updated at a later point with the
|
||
|
|
user_data_set() function.
|
||
|
|
|
||
|
|
The protocol argument allows explicit setting of the MQTT version to
|
||
|
|
use for this client. Can be paho.mqtt.client.MQTTv311 (v3.1.1) or
|
||
|
|
paho.mqtt.client.MQTTv31 (v3.1), with the default being v3.1.1 If the
|
||
|
|
broker reports that the client connected with an invalid protocol
|
||
|
|
version, the client will automatically attempt to reconnect using v3.1
|
||
|
|
instead.
|
||
|
|
|
||
|
|
Set transport to "websockets" to use WebSockets as the transport
|
||
|
|
mechanism. Set to "tcp" to use raw TCP, which is the default.
|
||
|
|
"""
|
||
|
|
if not clean_session and (client_id == "" or client_id is None):
|
||
|
|
raise ValueError('A client id must be provided if clean session is False.')
|
||
|
|
|
||
|
|
self._transport = transport
|
||
|
|
self._protocol = protocol
|
||
|
|
self._userdata = userdata
|
||
|
|
self._sock = None
|
||
|
|
self._sockpairR, self._sockpairW = _socketpair_compat()
|
||
|
|
self._keepalive = 60
|
||
|
|
self._message_retry = 20
|
||
|
|
self._last_retry_check = 0
|
||
|
|
self._clean_session = clean_session
|
||
|
|
|
||
|
|
# [MQTT-3.1.3-4] Client Id must be UTF-8 encoded string.
|
||
|
|
if client_id == "" or client_id is None:
|
||
|
|
if protocol == MQTTv31:
|
||
|
|
self._client_id = base62(uuid.uuid4().int, padding=22)
|
||
|
|
else:
|
||
|
|
self._client_id = b""
|
||
|
|
else:
|
||
|
|
self._client_id = client_id
|
||
|
|
if isinstance(self._client_id, unicode):
|
||
|
|
self._client_id = self._client_id.encode('utf-8')
|
||
|
|
|
||
|
|
self._username = None
|
||
|
|
self._password = None
|
||
|
|
self._in_packet = {
|
||
|
|
"command": 0,
|
||
|
|
"have_remaining": 0,
|
||
|
|
"remaining_count": [],
|
||
|
|
"remaining_mult": 1,
|
||
|
|
"remaining_length": 0,
|
||
|
|
"packet": b"",
|
||
|
|
"to_process": 0,
|
||
|
|
"pos": 0}
|
||
|
|
self._out_packet = collections.deque()
|
||
|
|
self._current_out_packet = None
|
||
|
|
self._last_msg_in = time_func()
|
||
|
|
self._last_msg_out = time_func()
|
||
|
|
self._reconnect_min_delay = 1
|
||
|
|
self._reconnect_max_delay = 120
|
||
|
|
self._reconnect_delay = None
|
||
|
|
self._ping_t = 0
|
||
|
|
self._last_mid = 0
|
||
|
|
self._state = mqtt_cs_new
|
||
|
|
self._out_messages = []
|
||
|
|
self._in_messages = []
|
||
|
|
self._max_inflight_messages = 20
|
||
|
|
self._inflight_messages = 0
|
||
|
|
self._max_queued_messages = 0
|
||
|
|
self._will = False
|
||
|
|
self._will_topic = b""
|
||
|
|
self._will_payload = b""
|
||
|
|
self._will_qos = 0
|
||
|
|
self._will_retain = False
|
||
|
|
self._on_message_filtered = MQTTMatcher()
|
||
|
|
self._host = ""
|
||
|
|
self._port = 1883
|
||
|
|
self._bind_address = ""
|
||
|
|
self._in_callback = threading.Lock()
|
||
|
|
self._callback_mutex = threading.RLock()
|
||
|
|
self._out_packet_mutex = threading.Lock()
|
||
|
|
self._current_out_packet_mutex = threading.RLock()
|
||
|
|
self._msgtime_mutex = threading.Lock()
|
||
|
|
self._out_message_mutex = threading.RLock()
|
||
|
|
self._in_message_mutex = threading.Lock()
|
||
|
|
self._reconnect_delay_mutex = threading.Lock()
|
||
|
|
self._thread = None
|
||
|
|
self._thread_terminate = False
|
||
|
|
self._ssl = False
|
||
|
|
self._ssl_context = None
|
||
|
|
self._tls_insecure = False # Only used when SSL context does not have check_hostname attribute
|
||
|
|
self._logger = None
|
||
|
|
# No default callbacks
|
||
|
|
self._on_log = None
|
||
|
|
self._on_connect = None
|
||
|
|
self._on_subscribe = None
|
||
|
|
self._on_message = None
|
||
|
|
self._on_publish = None
|
||
|
|
self._on_unsubscribe = None
|
||
|
|
self._on_disconnect = None
|
||
|
|
self._websocket_path = "/mqtt"
|
||
|
|
self._websocket_extra_headers = None
|
||
|
|
|
||
|
|
def __del__(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def reinitialise(self, client_id="", clean_session=True, userdata=None):
|
||
|
|
if self._sock:
|
||
|
|
self._sock.close()
|
||
|
|
self._sock = None
|
||
|
|
if self._sockpairR:
|
||
|
|
self._sockpairR.close()
|
||
|
|
self._sockpairR = None
|
||
|
|
if self._sockpairW:
|
||
|
|
self._sockpairW.close()
|
||
|
|
self._sockpairW = None
|
||
|
|
|
||
|
|
self.__init__(client_id, clean_session, userdata)
|
||
|
|
|
||
|
|
def ws_set_options(self, path="/mqtt", headers=None):
|
||
|
|
""" Set the path and headers for a websocket connection
|
||
|
|
|
||
|
|
path is a string starting with / which should be the endpoint of the
|
||
|
|
mqtt connection on the remote server
|
||
|
|
|
||
|
|
headers can be either a dict or a callable object. If it is a dict then
|
||
|
|
the extra items in the dict are added to the websocket headers. If it is
|
||
|
|
a callable, then the default websocket headers are passed into this
|
||
|
|
function and the result is used as the new headers.
|
||
|
|
"""
|
||
|
|
self._websocket_path = path
|
||
|
|
|
||
|
|
if headers is not None:
|
||
|
|
if isinstance(headers, dict) or callable(headers):
|
||
|
|
self._websocket_extra_headers = headers
|
||
|
|
else:
|
||
|
|
raise ValueError("'headers' option to ws_set_options has to be either a dictionary or callable")
|
||
|
|
|
||
|
|
def tls_set_context(self, context=None):
|
||
|
|
"""Configure network encryption and authentication context. Enables SSL/TLS support.
|
||
|
|
|
||
|
|
context : an ssl.SSLContext object. By default this is given by
|
||
|
|
`ssl.create_default_context()`, if available.
|
||
|
|
|
||
|
|
Must be called before connect() or connect_async()."""
|
||
|
|
if self._ssl_context is not None:
|
||
|
|
raise ValueError('SSL/TLS has already been configured.')
|
||
|
|
|
||
|
|
# Assume that have SSL support, or at least that context input behaves like ssl.SSLContext
|
||
|
|
# in current versions of Python
|
||
|
|
|
||
|
|
if context is None:
|
||
|
|
if hasattr(ssl, 'create_default_context'):
|
||
|
|
context = ssl.create_default_context()
|
||
|
|
else:
|
||
|
|
raise ValueError('SSL/TLS context must be specified')
|
||
|
|
|
||
|
|
self._ssl = True
|
||
|
|
self._ssl_context = context
|
||
|
|
|
||
|
|
# Ensure _tls_insecure is consistent with check_hostname attribute
|
||
|
|
if hasattr(context, 'check_hostname'):
|
||
|
|
self._tls_insecure = not context.check_hostname
|
||
|
|
|
||
|
|
def tls_set(self, ca_certs=None, certfile=None, keyfile=None, cert_reqs=None, tls_version=None, ciphers=None):
|
||
|
|
"""Configure network encryption and authentication options. Enables SSL/TLS support.
|
||
|
|
|
||
|
|
ca_certs : a string path to the Certificate Authority certificate files
|
||
|
|
that are to be treated as trusted by this client. If this is the only
|
||
|
|
option given then the client will operate in a similar manner to a web
|
||
|
|
browser. That is to say it will require the broker to have a
|
||
|
|
certificate signed by the Certificate Authorities in ca_certs and will
|
||
|
|
communicate using TLS v1, but will not attempt any form of
|
||
|
|
authentication. This provides basic network encryption but may not be
|
||
|
|
sufficient depending on how the broker is configured.
|
||
|
|
By default, on Python 2.7.9+ or 3.4+, the default certification
|
||
|
|
authority of the system is used. On older Python version this parameter
|
||
|
|
is mandatory.
|
||
|
|
|
||
|
|
certfile and keyfile are strings pointing to the PEM encoded client
|
||
|
|
certificate and private keys respectively. If these arguments are not
|
||
|
|
None then they will be used as client information for TLS based
|
||
|
|
authentication. Support for this feature is broker dependent. Note
|
||
|
|
that if either of these files in encrypted and needs a password to
|
||
|
|
decrypt it, Python will ask for the password at the command line. It is
|
||
|
|
not currently possible to define a callback to provide the password.
|
||
|
|
|
||
|
|
cert_reqs allows the certificate requirements that the client imposes
|
||
|
|
on the broker to be changed. By default this is ssl.CERT_REQUIRED,
|
||
|
|
which means that the broker must provide a certificate. See the ssl
|
||
|
|
pydoc for more information on this parameter.
|
||
|
|
|
||
|
|
tls_version allows the version of the SSL/TLS protocol used to be
|
||
|
|
specified. By default TLS v1 is used. Previous versions (all versions
|
||
|
|
beginning with SSL) are possible but not recommended due to possible
|
||
|
|
security problems.
|
||
|
|
|
||
|
|
ciphers is a string specifying which encryption ciphers are allowable
|
||
|
|
for this connection, or None to use the defaults. See the ssl pydoc for
|
||
|
|
more information.
|
||
|
|
|
||
|
|
Must be called before connect() or connect_async()."""
|
||
|
|
if ssl is None:
|
||
|
|
raise ValueError('This platform has no SSL/TLS.')
|
||
|
|
|
||
|
|
if not hasattr(ssl, 'SSLContext'):
|
||
|
|
# Require Python version that has SSL context support in standard library
|
||
|
|
raise ValueError('Python 2.7.9 and 3.2 are the minimum supported versions for TLS.')
|
||
|
|
|
||
|
|
if ca_certs is None and not hasattr(ssl.SSLContext, 'load_default_certs'):
|
||
|
|
raise ValueError('ca_certs must not be None.')
|
||
|
|
|
||
|
|
# Create SSLContext object
|
||
|
|
if tls_version is None:
|
||
|
|
tls_version = ssl.PROTOCOL_TLSv1
|
||
|
|
# If the python version supports it, use highest TLS version automatically
|
||
|
|
if hasattr(ssl, "PROTOCOL_TLS"):
|
||
|
|
tls_version = ssl.PROTOCOL_TLS
|
||
|
|
context = ssl.SSLContext(tls_version)
|
||
|
|
|
||
|
|
# Configure context
|
||
|
|
if certfile is not None:
|
||
|
|
context.load_cert_chain(certfile, keyfile)
|
||
|
|
|
||
|
|
if cert_reqs == ssl.CERT_NONE and hasattr(context, 'check_hostname'):
|
||
|
|
context.check_hostname = False
|
||
|
|
|
||
|
|
context.verify_mode = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs
|
||
|
|
|
||
|
|
if ca_certs is not None:
|
||
|
|
context.load_verify_locations(ca_certs)
|
||
|
|
else:
|
||
|
|
context.load_default_certs()
|
||
|
|
|
||
|
|
if ciphers is not None:
|
||
|
|
context.set_ciphers(ciphers)
|
||
|
|
|
||
|
|
self.tls_set_context(context)
|
||
|
|
|
||
|
|
if cert_reqs != ssl.CERT_NONE:
|
||
|
|
# Default to secure, sets context.check_hostname attribute
|
||
|
|
# if available
|
||
|
|
self.tls_insecure_set(False)
|
||
|
|
else:
|
||
|
|
# But with ssl.CERT_NONE, we can not check_hostname
|
||
|
|
self.tls_insecure_set(True)
|
||
|
|
|
||
|
|
def tls_insecure_set(self, value):
|
||
|
|
"""Configure verification of the server hostname in the server certificate.
|
||
|
|
|
||
|
|
If value is set to true, it is impossible to guarantee that the host
|
||
|
|
you are connecting to is not impersonating your server. This can be
|
||
|
|
useful in initial server testing, but makes it possible for a malicious
|
||
|
|
third party to impersonate your server through DNS spoofing, for
|
||
|
|
example.
|
||
|
|
|
||
|
|
Do not use this function in a real system. Setting value to true means
|
||
|
|
there is no point using encryption.
|
||
|
|
|
||
|
|
Must be called before connect() and after either tls_set() or
|
||
|
|
tls_set_context()."""
|
||
|
|
|
||
|
|
if self._ssl_context is None:
|
||
|
|
raise ValueError('Must configure SSL context before using tls_insecure_set.')
|
||
|
|
|
||
|
|
self._tls_insecure = value
|
||
|
|
|
||
|
|
# Ensure check_hostname is consistent with _tls_insecure attribute
|
||
|
|
if hasattr(self._ssl_context, 'check_hostname'):
|
||
|
|
# Rely on SSLContext to check host name
|
||
|
|
# If verify_mode is CERT_NONE then the host name will never be checked
|
||
|
|
self._ssl_context.check_hostname = not value
|
||
|
|
|
||
|
|
def enable_logger(self, logger=None):
|
||
|
|
if not logger:
|
||
|
|
if self._logger:
|
||
|
|
# Do not replace existing logger
|
||
|
|
return
|
||
|
|
logger = logging.getLogger(__name__)
|
||
|
|
self._logger = logger
|
||
|
|
|
||
|
|
def disable_logger(self):
|
||
|
|
self._logger = None
|
||
|
|
|
||
|
|
def connect(self, host, port=1883, keepalive=60, bind_address=""):
|
||
|
|
"""Connect to a remote broker.
|
||
|
|
|
||
|
|
host is the hostname or IP address of the remote broker.
|
||
|
|
port is the network port of the server host to connect to. Defaults to
|
||
|
|
1883. Note that the default port for MQTT over SSL/TLS is 8883 so if you
|
||
|
|
are using tls_set() the port may need providing.
|
||
|
|
keepalive: Maximum period in seconds between communications with the
|
||
|
|
broker. If no other messages are being exchanged, this controls the
|
||
|
|
rate at which the client will send ping messages to the broker.
|
||
|
|
"""
|
||
|
|
self.connect_async(host, port, keepalive, bind_address)
|
||
|
|
return self.reconnect()
|
||
|
|
|
||
|
|
def connect_srv(self, domain=None, keepalive=60, bind_address=""):
|
||
|
|
"""Connect to a remote broker.
|
||
|
|
|
||
|
|
domain is the DNS domain to search for SRV records; if None,
|
||
|
|
try to determine local domain name.
|
||
|
|
keepalive and bind_address are as for connect()
|
||
|
|
"""
|
||
|
|
|
||
|
|
if HAVE_DNS is False:
|
||
|
|
raise ValueError('No DNS resolver library found, try "pip install dnspython" or "pip3 install dnspython3".')
|
||
|
|
|
||
|
|
if domain is None:
|
||
|
|
domain = socket.getfqdn()
|
||
|
|
domain = domain[domain.find('.') + 1:]
|
||
|
|
|
||
|
|
try:
|
||
|
|
rr = '_mqtt._tcp.%s' % domain
|
||
|
|
if self._ssl:
|
||
|
|
# IANA specifies secure-mqtt (not mqtts) for port 8883
|
||
|
|
rr = '_secure-mqtt._tcp.%s' % domain
|
||
|
|
answers = []
|
||
|
|
for answer in dns.resolver.query(rr, dns.rdatatype.SRV):
|
||
|
|
addr = answer.target.to_text()[:-1]
|
||
|
|
answers.append((addr, answer.port, answer.priority, answer.weight))
|
||
|
|
except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer, dns.resolver.NoNameservers):
|
||
|
|
raise ValueError("No answer/NXDOMAIN for SRV in %s" % (domain))
|
||
|
|
|
||
|
|
# FIXME: doesn't account for weight
|
||
|
|
for answer in answers:
|
||
|
|
host, port, prio, weight = answer
|
||
|
|
|
||
|
|
try:
|
||
|
|
return self.connect(host, port, keepalive, bind_address)
|
||
|
|
except:
|
||
|
|
pass
|
||
|
|
|
||
|
|
raise ValueError("No SRV hosts responded")
|
||
|
|
|
||
|
|
def connect_async(self, host, port=1883, keepalive=60, bind_address=""):
|
||
|
|
"""Connect to a remote broker asynchronously. This is a non-blocking
|
||
|
|
connect call that can be used with loop_start() to provide very quick
|
||
|
|
start.
|
||
|
|
|
||
|
|
host is the hostname or IP address of the remote broker.
|
||
|
|
port is the network port of the server host to connect to. Defaults to
|
||
|
|
1883. Note that the default port for MQTT over SSL/TLS is 8883 so if you
|
||
|
|
are using tls_set() the port may need providing.
|
||
|
|
keepalive: Maximum period in seconds between communications with the
|
||
|
|
broker. If no other messages are being exchanged, this controls the
|
||
|
|
rate at which the client will send ping messages to the broker.
|
||
|
|
"""
|
||
|
|
if host is None or len(host) == 0:
|
||
|
|
raise ValueError('Invalid host.')
|
||
|
|
if port <= 0:
|
||
|
|
raise ValueError('Invalid port number.')
|
||
|
|
if keepalive < 0:
|
||
|
|
raise ValueError('Keepalive must be >=0.')
|
||
|
|
if bind_address != "" and bind_address is not None:
|
||
|
|
if (sys.version_info[0] == 2 and sys.version_info[1] < 7) or (
|
||
|
|
sys.version_info[0] == 3 and sys.version_info[1] < 2):
|
||
|
|
raise ValueError('bind_address requires Python 2.7 or 3.2.')
|
||
|
|
|
||
|
|
self._host = host
|
||
|
|
self._port = port
|
||
|
|
self._keepalive = keepalive
|
||
|
|
self._bind_address = bind_address
|
||
|
|
|
||
|
|
self._state = mqtt_cs_connect_async
|
||
|
|
|
||
|
|
def reconnect_delay_set(self, min_delay=1, max_delay=120):
|
||
|
|
""" Configure the exponential reconnect delay
|
||
|
|
|
||
|
|
When connection is lost, wait initially min_delay seconds and
|
||
|
|
double this time every attempt. The wait is capped at max_delay.
|
||
|
|
Once the client is fully connected (e.g. not only TCP socket, but
|
||
|
|
received a success CONNACK), the wait timer is reset to min_delay.
|
||
|
|
"""
|
||
|
|
with self._reconnect_delay_mutex:
|
||
|
|
self._reconnect_min_delay = min_delay
|
||
|
|
self._reconnect_max_delay = max_delay
|
||
|
|
self._reconnect_delay = None
|
||
|
|
|
||
|
|
def reconnect(self):
|
||
|
|
"""Reconnect the client after a disconnect. Can only be called after
|
||
|
|
connect()/connect_async()."""
|
||
|
|
if len(self._host) == 0:
|
||
|
|
raise ValueError('Invalid host.')
|
||
|
|
if self._port <= 0:
|
||
|
|
raise ValueError('Invalid port number.')
|
||
|
|
|
||
|
|
self._in_packet = {
|
||
|
|
"command": 0,
|
||
|
|
"have_remaining": 0,
|
||
|
|
"remaining_count": [],
|
||
|
|
"remaining_mult": 1,
|
||
|
|
"remaining_length": 0,
|
||
|
|
"packet": b"",
|
||
|
|
"to_process": 0,
|
||
|
|
"pos": 0}
|
||
|
|
|
||
|
|
with self._out_packet_mutex:
|
||
|
|
self._out_packet = collections.deque()
|
||
|
|
|
||
|
|
with self._current_out_packet_mutex:
|
||
|
|
self._current_out_packet = None
|
||
|
|
|
||
|
|
with self._msgtime_mutex:
|
||
|
|
self._last_msg_in = time_func()
|
||
|
|
self._last_msg_out = time_func()
|
||
|
|
|
||
|
|
self._ping_t = 0
|
||
|
|
self._state = mqtt_cs_new
|
||
|
|
|
||
|
|
if self._sock:
|
||
|
|
self._sock.close()
|
||
|
|
self._sock = None
|
||
|
|
|
||
|
|
# Put messages in progress in a valid state.
|
||
|
|
self._messages_reconnect_reset()
|
||
|
|
|
||
|
|
try:
|
||
|
|
if (sys.version_info[0] == 2 and sys.version_info[1] < 7) or (
|
||
|
|
sys.version_info[0] == 3 and sys.version_info[1] < 2):
|
||
|
|
sock = socket.create_connection((self._host, self._port))
|
||
|
|
else:
|
||
|
|
sock = socket.create_connection((self._host, self._port), source_address=(self._bind_address, 0))
|
||
|
|
except socket.error as err:
|
||
|
|
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
|
||
|
|
raise
|
||
|
|
|
||
|
|
if self._ssl:
|
||
|
|
# SSL is only supported when SSLContext is available (implies Python >= 2.7.9 or >= 3.2)
|
||
|
|
|
||
|
|
verify_host = not self._tls_insecure
|
||
|
|
try:
|
||
|
|
# Try with server_hostname, even it's not supported in certain scenarios
|
||
|
|
sock = self._ssl_context.wrap_socket(
|
||
|
|
sock,
|
||
|
|
server_hostname=self._host,
|
||
|
|
do_handshake_on_connect=False,
|
||
|
|
)
|
||
|
|
except ssl.CertificateError:
|
||
|
|
# CertificateError is derived from ValueError
|
||
|
|
raise
|
||
|
|
except ValueError:
|
||
|
|
# Python version requires SNI in order to handle server_hostname, but SNI is not available
|
||
|
|
sock = self._ssl_context.wrap_socket(
|
||
|
|
sock,
|
||
|
|
do_handshake_on_connect=False,
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
# If SSL context has already checked hostname, then don't need to do it again
|
||
|
|
if (hasattr(self._ssl_context, 'check_hostname') and
|
||
|
|
self._ssl_context.check_hostname):
|
||
|
|
verify_host = False
|
||
|
|
|
||
|
|
sock.settimeout(self._keepalive)
|
||
|
|
sock.do_handshake()
|
||
|
|
|
||
|
|
if verify_host:
|
||
|
|
ssl.match_hostname(sock.getpeercert(), self._host)
|
||
|
|
|
||
|
|
if self._transport == "websockets":
|
||
|
|
sock.settimeout(self._keepalive)
|
||
|
|
sock = WebsocketWrapper(sock, self._host, self._port, self._ssl,
|
||
|
|
self._websocket_path, self._websocket_extra_headers)
|
||
|
|
|
||
|
|
self._sock = sock
|
||
|
|
self._sock.setblocking(0)
|
||
|
|
|
||
|
|
return self._send_connect(self._keepalive, self._clean_session)
|
||
|
|
|
||
|
|
def loop(self, timeout=1.0, max_packets=1):
|
||
|
|
"""Process network events.
|
||
|
|
|
||
|
|
This function must be called regularly to ensure communication with the
|
||
|
|
broker is carried out. It calls select() on the network socket to wait
|
||
|
|
for network events. If incoming data is present it will then be
|
||
|
|
processed. Outgoing commands, from e.g. publish(), are normally sent
|
||
|
|
immediately that their function is called, but this is not always
|
||
|
|
possible. loop() will also attempt to send any remaining outgoing
|
||
|
|
messages, which also includes commands that are part of the flow for
|
||
|
|
messages with QoS>0.
|
||
|
|
|
||
|
|
timeout: The time in seconds to wait for incoming/outgoing network
|
||
|
|
traffic before timing out and returning.
|
||
|
|
max_packets: Not currently used.
|
||
|
|
|
||
|
|
Returns MQTT_ERR_SUCCESS on success.
|
||
|
|
Returns >0 on error.
|
||
|
|
|
||
|
|
A ValueError will be raised if timeout < 0"""
|
||
|
|
if timeout < 0.0:
|
||
|
|
raise ValueError('Invalid timeout.')
|
||
|
|
|
||
|
|
with self._current_out_packet_mutex:
|
||
|
|
with self._out_packet_mutex:
|
||
|
|
if self._current_out_packet is None and len(self._out_packet) > 0:
|
||
|
|
self._current_out_packet = self._out_packet.popleft()
|
||
|
|
|
||
|
|
if self._current_out_packet:
|
||
|
|
wlist = [self._sock]
|
||
|
|
else:
|
||
|
|
wlist = []
|
||
|
|
|
||
|
|
# used to check if there are any bytes left in the (SSL) socket
|
||
|
|
pending_bytes = 0
|
||
|
|
if hasattr(self._sock, 'pending'):
|
||
|
|
pending_bytes = self._sock.pending()
|
||
|
|
|
||
|
|
# if bytes are pending do not wait in select
|
||
|
|
if pending_bytes > 0:
|
||
|
|
timeout = 0.0
|
||
|
|
|
||
|
|
# sockpairR is used to break out of select() before the timeout, on a
|
||
|
|
# call to publish() etc.
|
||
|
|
rlist = [self._sock, self._sockpairR]
|
||
|
|
try:
|
||
|
|
socklist = select.select(rlist, wlist, [], timeout)
|
||
|
|
except TypeError:
|
||
|
|
# Socket isn't correct type, in likelihood connection is lost
|
||
|
|
return MQTT_ERR_CONN_LOST
|
||
|
|
except ValueError:
|
||
|
|
# Can occur if we just reconnected but rlist/wlist contain a -1 for
|
||
|
|
# some reason.
|
||
|
|
return MQTT_ERR_CONN_LOST
|
||
|
|
except KeyboardInterrupt:
|
||
|
|
# Allow ^C to interrupt
|
||
|
|
raise
|
||
|
|
except:
|
||
|
|
return MQTT_ERR_UNKNOWN
|
||
|
|
|
||
|
|
if self._sock in socklist[0] or pending_bytes > 0:
|
||
|
|
rc = self.loop_read(max_packets)
|
||
|
|
if rc or self._sock is None:
|
||
|
|
return rc
|
||
|
|
|
||
|
|
if self._sockpairR in socklist[0]:
|
||
|
|
# Stimulate output write even though we didn't ask for it, because
|
||
|
|
# at that point the publish or other command wasn't present.
|
||
|
|
socklist[1].insert(0, self._sock)
|
||
|
|
# Clear sockpairR - only ever a single byte written.
|
||
|
|
try:
|
||
|
|
self._sockpairR.recv(1)
|
||
|
|
except socket.error as err:
|
||
|
|
if err.errno != EAGAIN:
|
||
|
|
raise
|
||
|
|
|
||
|
|
if self._sock in socklist[1]:
|
||
|
|
rc = self.loop_write(max_packets)
|
||
|
|
if rc or self._sock is None:
|
||
|
|
return rc
|
||
|
|
|
||
|
|
return self.loop_misc()
|
||
|
|
|
||
|
|
def publish(self, topic, payload=None, qos=0, retain=False):
|
||
|
|
"""Publish a message on a topic.
|
||
|
|
|
||
|
|
This causes a message to be sent to the broker and subsequently from
|
||
|
|
the broker to any clients subscribing to matching topics.
|
||
|
|
|
||
|
|
topic: The topic that the message should be published on.
|
||
|
|
payload: The actual message to send. If not given, or set to None a
|
||
|
|
zero length message will be used. Passing an int or float will result
|
||
|
|
in the payload being converted to a string representing that number. If
|
||
|
|
you wish to send a true int/float, use struct.pack() to create the
|
||
|
|
payload you require.
|
||
|
|
qos: The quality of service level to use.
|
||
|
|
retain: If set to true, the message will be set as the "last known
|
||
|
|
good"/retained message for the topic.
|
||
|
|
|
||
|
|
Returns a MQTTMessageInfo class, which can be used to determine whether
|
||
|
|
the message has been delivered (using info.is_published()) or to block
|
||
|
|
waiting for the message to be delivered (info.wait_for_publish()). The
|
||
|
|
message ID and return code of the publish() call can be found at
|
||
|
|
info.mid and info.rc.
|
||
|
|
|
||
|
|
For backwards compatibility, the MQTTMessageInfo class is iterable so
|
||
|
|
the old construct of (rc, mid) = client.publish(...) is still valid.
|
||
|
|
|
||
|
|
rc is MQTT_ERR_SUCCESS to indicate success or MQTT_ERR_NO_CONN if the
|
||
|
|
client is not currently connected. mid is the message ID for the
|
||
|
|
publish request. The mid value can be used to track the publish request
|
||
|
|
by checking against the mid argument in the on_publish() callback if it
|
||
|
|
is defined.
|
||
|
|
|
||
|
|
A ValueError will be raised if topic is None, has zero length or is
|
||
|
|
invalid (contains a wildcard), if qos is not one of 0, 1 or 2, or if
|
||
|
|
the length of the payload is greater than 268435455 bytes."""
|
||
|
|
if topic is None or len(topic) == 0:
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
|
||
|
|
topic = topic.encode('utf-8')
|
||
|
|
|
||
|
|
if self._topic_wildcard_len_check(topic) != MQTT_ERR_SUCCESS:
|
||
|
|
raise ValueError('Publish topic cannot contain wildcards.')
|
||
|
|
|
||
|
|
if qos < 0 or qos > 2:
|
||
|
|
raise ValueError('Invalid QoS level.')
|
||
|
|
|
||
|
|
if isinstance(payload, unicode):
|
||
|
|
local_payload = payload.encode('utf-8')
|
||
|
|
elif isinstance(payload, (bytes, bytearray)):
|
||
|
|
local_payload = payload
|
||
|
|
elif isinstance(payload, (int, float)):
|
||
|
|
local_payload = str(payload).encode('ascii')
|
||
|
|
elif payload is None:
|
||
|
|
local_payload = b''
|
||
|
|
else:
|
||
|
|
raise TypeError('payload must be a string, bytearray, int, float or None.')
|
||
|
|
|
||
|
|
if len(local_payload) > 268435455:
|
||
|
|
raise ValueError('Payload too large.')
|
||
|
|
|
||
|
|
local_mid = self._mid_generate()
|
||
|
|
|
||
|
|
if qos == 0:
|
||
|
|
info = MQTTMessageInfo(local_mid)
|
||
|
|
rc = self._send_publish(local_mid, topic, local_payload, qos, retain, False, info)
|
||
|
|
info.rc = rc
|
||
|
|
return info
|
||
|
|
else:
|
||
|
|
message = MQTTMessage(local_mid, topic)
|
||
|
|
message.timestamp = time_func()
|
||
|
|
message.payload = local_payload
|
||
|
|
message.qos = qos
|
||
|
|
message.retain = retain
|
||
|
|
message.dup = False
|
||
|
|
|
||
|
|
with self._out_message_mutex:
|
||
|
|
if self._max_queued_messages > 0 and len(self._out_messages) >= self._max_queued_messages:
|
||
|
|
message.info.rc = MQTT_ERR_QUEUE_SIZE
|
||
|
|
return message.info
|
||
|
|
|
||
|
|
self._out_messages.append(message)
|
||
|
|
if self._max_inflight_messages == 0 or self._inflight_messages < self._max_inflight_messages:
|
||
|
|
self._inflight_messages += 1
|
||
|
|
if qos == 1:
|
||
|
|
message.state = mqtt_ms_wait_for_puback
|
||
|
|
elif qos == 2:
|
||
|
|
message.state = mqtt_ms_wait_for_pubrec
|
||
|
|
|
||
|
|
rc = self._send_publish(message.mid, topic, message.payload, message.qos, message.retain,
|
||
|
|
message.dup)
|
||
|
|
|
||
|
|
# remove from inflight messages so it will be send after a connection is made
|
||
|
|
if rc is MQTT_ERR_NO_CONN:
|
||
|
|
self._inflight_messages -= 1
|
||
|
|
message.state = mqtt_ms_publish
|
||
|
|
|
||
|
|
message.info.rc = rc
|
||
|
|
return message.info
|
||
|
|
else:
|
||
|
|
message.state = mqtt_ms_queued
|
||
|
|
message.info.rc = MQTT_ERR_SUCCESS
|
||
|
|
return message.info
|
||
|
|
|
||
|
|
def username_pw_set(self, username, password=None):
|
||
|
|
"""Set a username and optionally a password for broker authentication.
|
||
|
|
|
||
|
|
Must be called before connect() to have any effect.
|
||
|
|
Requires a broker that supports MQTT v3.1.
|
||
|
|
|
||
|
|
username: The username to authenticate with. Need have no relationship to the client id. Must be unicode
|
||
|
|
[MQTT-3.1.3-11].
|
||
|
|
password: The password to authenticate with. Optional, set to None if not required. If it is unicode, then it
|
||
|
|
will be encoded as UTF-8.
|
||
|
|
"""
|
||
|
|
|
||
|
|
# [MQTT-3.1.3-11] User name must be UTF-8 encoded string
|
||
|
|
self._username = username.encode('utf-8')
|
||
|
|
self._password = password
|
||
|
|
if isinstance(self._password, unicode):
|
||
|
|
self._password = self._password.encode('utf-8')
|
||
|
|
|
||
|
|
def disconnect(self):
|
||
|
|
"""Disconnect a connected client from the broker."""
|
||
|
|
self._state = mqtt_cs_disconnecting
|
||
|
|
|
||
|
|
if self._sock is None:
|
||
|
|
return MQTT_ERR_NO_CONN
|
||
|
|
|
||
|
|
return self._send_disconnect()
|
||
|
|
|
||
|
|
def subscribe(self, topic, qos=0):
|
||
|
|
"""Subscribe the client to one or more topics.
|
||
|
|
|
||
|
|
This function may be called in three different ways:
|
||
|
|
|
||
|
|
Simple string and integer
|
||
|
|
-------------------------
|
||
|
|
e.g. subscribe("my/topic", 2)
|
||
|
|
|
||
|
|
topic: A string specifying the subscription topic to subscribe to.
|
||
|
|
qos: The desired quality of service level for the subscription.
|
||
|
|
Defaults to 0.
|
||
|
|
|
||
|
|
String and integer tuple
|
||
|
|
------------------------
|
||
|
|
e.g. subscribe(("my/topic", 1))
|
||
|
|
|
||
|
|
topic: A tuple of (topic, qos). Both topic and qos must be present in
|
||
|
|
the tuple.
|
||
|
|
qos: Not used.
|
||
|
|
|
||
|
|
List of string and integer tuples
|
||
|
|
------------------------
|
||
|
|
e.g. subscribe([("my/topic", 0), ("another/topic", 2)])
|
||
|
|
|
||
|
|
This allows multiple topic subscriptions in a single SUBSCRIPTION
|
||
|
|
command, which is more efficient than using multiple calls to
|
||
|
|
subscribe().
|
||
|
|
|
||
|
|
topic: A list of tuple of format (topic, qos). Both topic and qos must
|
||
|
|
be present in all of the tuples.
|
||
|
|
qos: Not used.
|
||
|
|
|
||
|
|
The function returns a tuple (result, mid), where result is
|
||
|
|
MQTT_ERR_SUCCESS to indicate success or (MQTT_ERR_NO_CONN, None) if the
|
||
|
|
client is not currently connected. mid is the message ID for the
|
||
|
|
subscribe request. The mid value can be used to track the subscribe
|
||
|
|
request by checking against the mid argument in the on_subscribe()
|
||
|
|
callback if it is defined.
|
||
|
|
|
||
|
|
Raises a ValueError if qos is not 0, 1 or 2, or if topic is None or has
|
||
|
|
zero string length, or if topic is not a string, tuple or list.
|
||
|
|
"""
|
||
|
|
topic_qos_list = None
|
||
|
|
|
||
|
|
if isinstance(topic, tuple):
|
||
|
|
topic, qos = topic
|
||
|
|
|
||
|
|
if isinstance(topic, basestring):
|
||
|
|
if qos < 0 or qos > 2:
|
||
|
|
raise ValueError('Invalid QoS level.')
|
||
|
|
if topic is None or len(topic) == 0:
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
topic_qos_list = [(topic.encode('utf-8'), qos)]
|
||
|
|
elif isinstance(topic, list):
|
||
|
|
topic_qos_list = []
|
||
|
|
for t, q in topic:
|
||
|
|
if q < 0 or q > 2:
|
||
|
|
raise ValueError('Invalid QoS level.')
|
||
|
|
if t is None or len(t) == 0 or not isinstance(t, basestring):
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
topic_qos_list.append((t.encode('utf-8'), q))
|
||
|
|
|
||
|
|
if topic_qos_list is None:
|
||
|
|
raise ValueError("No topic specified, or incorrect topic type.")
|
||
|
|
|
||
|
|
if any(self._filter_wildcard_len_check(topic) != MQTT_ERR_SUCCESS for topic, _ in topic_qos_list):
|
||
|
|
raise ValueError('Invalid subscription filter.')
|
||
|
|
|
||
|
|
if self._sock is None:
|
||
|
|
return (MQTT_ERR_NO_CONN, None)
|
||
|
|
|
||
|
|
return self._send_subscribe(False, topic_qos_list)
|
||
|
|
|
||
|
|
def unsubscribe(self, topic):
|
||
|
|
"""Unsubscribe the client from one or more topics.
|
||
|
|
|
||
|
|
topic: A single string, or list of strings that are the subscription
|
||
|
|
topics to unsubscribe from.
|
||
|
|
|
||
|
|
Returns a tuple (result, mid), where result is MQTT_ERR_SUCCESS
|
||
|
|
to indicate success or (MQTT_ERR_NO_CONN, None) if the client is not
|
||
|
|
currently connected.
|
||
|
|
mid is the message ID for the unsubscribe request. The mid value can be
|
||
|
|
used to track the unsubscribe request by checking against the mid
|
||
|
|
argument in the on_unsubscribe() callback if it is defined.
|
||
|
|
|
||
|
|
Raises a ValueError if topic is None or has zero string length, or is
|
||
|
|
not a string or list.
|
||
|
|
"""
|
||
|
|
topic_list = None
|
||
|
|
if topic is None:
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
if isinstance(topic, basestring):
|
||
|
|
if len(topic) == 0:
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
topic_list = [topic.encode('utf-8')]
|
||
|
|
elif isinstance(topic, list):
|
||
|
|
topic_list = []
|
||
|
|
for t in topic:
|
||
|
|
if len(t) == 0 or not isinstance(t, basestring):
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
topic_list.append(t.encode('utf-8'))
|
||
|
|
|
||
|
|
if topic_list is None:
|
||
|
|
raise ValueError("No topic specified, or incorrect topic type.")
|
||
|
|
|
||
|
|
if self._sock is None:
|
||
|
|
return (MQTT_ERR_NO_CONN, None)
|
||
|
|
|
||
|
|
return self._send_unsubscribe(False, topic_list)
|
||
|
|
|
||
|
|
def loop_read(self, max_packets=1):
|
||
|
|
"""Process read network events. Use in place of calling loop() if you
|
||
|
|
wish to handle your client reads as part of your own application.
|
||
|
|
|
||
|
|
Use socket() to obtain the client socket to call select() or equivalent
|
||
|
|
on.
|
||
|
|
|
||
|
|
Do not use if you are using the threaded interface loop_start()."""
|
||
|
|
if self._sock is None:
|
||
|
|
return MQTT_ERR_NO_CONN
|
||
|
|
|
||
|
|
max_packets = len(self._out_messages) + len(self._in_messages)
|
||
|
|
if max_packets < 1:
|
||
|
|
max_packets = 1
|
||
|
|
|
||
|
|
for _ in range(0, max_packets):
|
||
|
|
if self._sock is None:
|
||
|
|
return MQTT_ERR_NO_CONN
|
||
|
|
rc = self._packet_read()
|
||
|
|
if rc > 0:
|
||
|
|
return self._loop_rc_handle(rc)
|
||
|
|
elif rc == MQTT_ERR_AGAIN:
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def loop_write(self, max_packets=1):
|
||
|
|
"""Process write network events. Use in place of calling loop() if you
|
||
|
|
wish to handle your client writes as part of your own application.
|
||
|
|
|
||
|
|
Use socket() to obtain the client socket to call select() or equivalent
|
||
|
|
on.
|
||
|
|
|
||
|
|
Use want_write() to determine if there is data waiting to be written.
|
||
|
|
|
||
|
|
Do not use if you are using the threaded interface loop_start()."""
|
||
|
|
if self._sock is None:
|
||
|
|
return MQTT_ERR_NO_CONN
|
||
|
|
|
||
|
|
max_packets = len(self._out_packet) + 1
|
||
|
|
if max_packets < 1:
|
||
|
|
max_packets = 1
|
||
|
|
|
||
|
|
for _ in range(0, max_packets):
|
||
|
|
rc = self._packet_write()
|
||
|
|
if rc > 0:
|
||
|
|
return self._loop_rc_handle(rc)
|
||
|
|
elif rc == MQTT_ERR_AGAIN:
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def want_write(self):
|
||
|
|
"""Call to determine if there is network data waiting to be written.
|
||
|
|
Useful if you are calling select() yourself rather than using loop().
|
||
|
|
"""
|
||
|
|
if self._current_out_packet or len(self._out_packet) > 0:
|
||
|
|
return True
|
||
|
|
else:
|
||
|
|
return False
|
||
|
|
|
||
|
|
def loop_misc(self):
|
||
|
|
"""Process miscellaneous network events. Use in place of calling loop() if you
|
||
|
|
wish to call select() or equivalent on.
|
||
|
|
|
||
|
|
Do not use if you are using the threaded interface loop_start()."""
|
||
|
|
if self._sock is None:
|
||
|
|
return MQTT_ERR_NO_CONN
|
||
|
|
|
||
|
|
now = time_func()
|
||
|
|
self._check_keepalive()
|
||
|
|
if self._last_retry_check + 1 < now:
|
||
|
|
# Only check once a second at most
|
||
|
|
self._message_retry_check()
|
||
|
|
self._last_retry_check = now
|
||
|
|
|
||
|
|
if self._ping_t > 0 and now - self._ping_t >= self._keepalive:
|
||
|
|
# client->ping_t != 0 means we are waiting for a pingresp.
|
||
|
|
# This hasn't happened in the keepalive time so we should disconnect.
|
||
|
|
if self._sock:
|
||
|
|
self._sock.close()
|
||
|
|
self._sock = None
|
||
|
|
|
||
|
|
if self._state == mqtt_cs_disconnecting:
|
||
|
|
rc = MQTT_ERR_SUCCESS
|
||
|
|
else:
|
||
|
|
rc = 1
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_disconnect:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_disconnect(self, self._userdata, rc)
|
||
|
|
|
||
|
|
return MQTT_ERR_CONN_LOST
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def max_inflight_messages_set(self, inflight):
|
||
|
|
"""Set the maximum number of messages with QoS>0 that can be part way
|
||
|
|
through their network flow at once. Defaults to 20."""
|
||
|
|
if inflight < 0:
|
||
|
|
raise ValueError('Invalid inflight.')
|
||
|
|
self._max_inflight_messages = inflight
|
||
|
|
|
||
|
|
def max_queued_messages_set(self, queue_size):
|
||
|
|
"""Set the maximum number of messages in the outgoing message queue.
|
||
|
|
0 means unlimited."""
|
||
|
|
if queue_size < 0:
|
||
|
|
raise ValueError('Invalid queue size.')
|
||
|
|
if not isinstance(queue_size, int):
|
||
|
|
raise ValueError('Invalid type of queue size.')
|
||
|
|
self._max_queued_messages = queue_size
|
||
|
|
return self
|
||
|
|
|
||
|
|
def message_retry_set(self, retry):
|
||
|
|
"""Set the timeout in seconds before a message with QoS>0 is retried.
|
||
|
|
20 seconds by default."""
|
||
|
|
if retry < 0:
|
||
|
|
raise ValueError('Invalid retry.')
|
||
|
|
|
||
|
|
self._message_retry = retry
|
||
|
|
|
||
|
|
def user_data_set(self, userdata):
|
||
|
|
"""Set the user data variable passed to callbacks. May be any data type."""
|
||
|
|
self._userdata = userdata
|
||
|
|
|
||
|
|
def will_set(self, topic, payload=None, qos=0, retain=False):
|
||
|
|
"""Set a Will to be sent by the broker in case the client disconnects unexpectedly.
|
||
|
|
|
||
|
|
This must be called before connect() to have any effect.
|
||
|
|
|
||
|
|
topic: The topic that the will message should be published on.
|
||
|
|
payload: The message to send as a will. If not given, or set to None a
|
||
|
|
zero length message will be used as the will. Passing an int or float
|
||
|
|
will result in the payload being converted to a string representing
|
||
|
|
that number. If you wish to send a true int/float, use struct.pack() to
|
||
|
|
create the payload you require.
|
||
|
|
qos: The quality of service level to use for the will.
|
||
|
|
retain: If set to true, the will message will be set as the "last known
|
||
|
|
good"/retained message for the topic.
|
||
|
|
|
||
|
|
Raises a ValueError if qos is not 0, 1 or 2, or if topic is None or has
|
||
|
|
zero string length.
|
||
|
|
"""
|
||
|
|
if topic is None or len(topic) == 0:
|
||
|
|
raise ValueError('Invalid topic.')
|
||
|
|
|
||
|
|
if qos < 0 or qos > 2:
|
||
|
|
raise ValueError('Invalid QoS level.')
|
||
|
|
|
||
|
|
if isinstance(payload, unicode):
|
||
|
|
self._will_payload = payload.encode('utf-8')
|
||
|
|
elif isinstance(payload, (bytes, bytearray)):
|
||
|
|
self._will_payload = payload
|
||
|
|
elif isinstance(payload, (int, float)):
|
||
|
|
self._will_payload = str(payload).encode('ascii')
|
||
|
|
elif payload is None:
|
||
|
|
self._will_payload = b""
|
||
|
|
else:
|
||
|
|
raise TypeError('payload must be a string, bytearray, int, float or None.')
|
||
|
|
|
||
|
|
self._will = True
|
||
|
|
self._will_topic = topic.encode('utf-8')
|
||
|
|
self._will_qos = qos
|
||
|
|
self._will_retain = retain
|
||
|
|
|
||
|
|
def will_clear(self):
|
||
|
|
""" Removes a will that was previously configured with will_set().
|
||
|
|
|
||
|
|
Must be called before connect() to have any effect."""
|
||
|
|
self._will = False
|
||
|
|
self._will_topic = b""
|
||
|
|
self._will_payload = b""
|
||
|
|
self._will_qos = 0
|
||
|
|
self._will_retain = False
|
||
|
|
|
||
|
|
def socket(self):
|
||
|
|
"""Return the socket or ssl object for this client."""
|
||
|
|
return self._sock
|
||
|
|
|
||
|
|
def loop_forever(self, timeout=1.0, max_packets=1, retry_first_connection=False):
|
||
|
|
"""This function call loop() for you in an infinite blocking loop. It
|
||
|
|
is useful for the case where you only want to run the MQTT client loop
|
||
|
|
in your program.
|
||
|
|
|
||
|
|
loop_forever() will handle reconnecting for you. If you call
|
||
|
|
disconnect() in a callback it will return.
|
||
|
|
|
||
|
|
|
||
|
|
timeout: The time in seconds to wait for incoming/outgoing network
|
||
|
|
traffic before timing out and returning.
|
||
|
|
max_packets: Not currently used.
|
||
|
|
retry_first_connection: Should the first connection attempt be retried on failure.
|
||
|
|
|
||
|
|
Raises socket.error on first connection failures unless retry_first_connection=True
|
||
|
|
"""
|
||
|
|
|
||
|
|
run = True
|
||
|
|
|
||
|
|
while run:
|
||
|
|
if self._thread_terminate is True:
|
||
|
|
break
|
||
|
|
|
||
|
|
if self._state == mqtt_cs_connect_async:
|
||
|
|
try:
|
||
|
|
self.reconnect()
|
||
|
|
except (socket.error, WebsocketConnectionError):
|
||
|
|
if not retry_first_connection:
|
||
|
|
raise
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Connection failed, retrying")
|
||
|
|
self._reconnect_wait()
|
||
|
|
else:
|
||
|
|
break
|
||
|
|
|
||
|
|
while run:
|
||
|
|
rc = MQTT_ERR_SUCCESS
|
||
|
|
while rc == MQTT_ERR_SUCCESS:
|
||
|
|
rc = self.loop(timeout, max_packets)
|
||
|
|
# We don't need to worry about locking here, because we've
|
||
|
|
# either called loop_forever() when in single threaded mode, or
|
||
|
|
# in multi threaded mode when loop_stop() has been called and
|
||
|
|
# so no other threads can access _current_out_packet,
|
||
|
|
# _out_packet or _messages.
|
||
|
|
if (self._thread_terminate is True
|
||
|
|
and self._current_out_packet is None
|
||
|
|
and len(self._out_packet) == 0
|
||
|
|
and len(self._out_messages) == 0):
|
||
|
|
rc = 1
|
||
|
|
run = False
|
||
|
|
|
||
|
|
|
||
|
|
def should_exit():
|
||
|
|
return self._state == mqtt_cs_disconnecting or run is False or self._thread_terminate is True
|
||
|
|
|
||
|
|
if should_exit():
|
||
|
|
run = False
|
||
|
|
else:
|
||
|
|
self._reconnect_wait()
|
||
|
|
|
||
|
|
if should_exit():
|
||
|
|
run = False
|
||
|
|
else:
|
||
|
|
try:
|
||
|
|
self.reconnect()
|
||
|
|
except (socket.error, WebsocketConnectionError):
|
||
|
|
pass
|
||
|
|
|
||
|
|
return rc
|
||
|
|
|
||
|
|
def loop_start(self):
|
||
|
|
"""This is part of the threaded client interface. Call this once to
|
||
|
|
start a new thread to process network traffic. This provides an
|
||
|
|
alternative to repeatedly calling loop() yourself.
|
||
|
|
"""
|
||
|
|
if self._thread is not None:
|
||
|
|
return MQTT_ERR_INVAL
|
||
|
|
|
||
|
|
self._thread_terminate = False
|
||
|
|
self._thread = threading.Thread(target=self._thread_main)
|
||
|
|
self._thread.daemon = True
|
||
|
|
self._thread.start()
|
||
|
|
|
||
|
|
def loop_stop(self, force=False):
|
||
|
|
"""This is part of the threaded client interface. Call this once to
|
||
|
|
stop the network thread previously created with loop_start(). This call
|
||
|
|
will block until the network thread finishes.
|
||
|
|
|
||
|
|
The force parameter is currently ignored.
|
||
|
|
"""
|
||
|
|
if self._thread is None:
|
||
|
|
return MQTT_ERR_INVAL
|
||
|
|
|
||
|
|
self._thread_terminate = True
|
||
|
|
if threading.current_thread() != self._thread:
|
||
|
|
self._thread.join()
|
||
|
|
self._thread = None
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_log(self):
|
||
|
|
"""If implemented, called when the client has log information.
|
||
|
|
Defined to allow debugging."""
|
||
|
|
return self._on_log
|
||
|
|
|
||
|
|
@on_log.setter
|
||
|
|
def on_log(self, func):
|
||
|
|
""" Define the logging callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
log_callback(client, userdata, level, buf)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
level: gives the severity of the message and will be one of
|
||
|
|
MQTT_LOG_INFO, MQTT_LOG_NOTICE, MQTT_LOG_WARNING,
|
||
|
|
MQTT_LOG_ERR, and MQTT_LOG_DEBUG.
|
||
|
|
buf: the message itself
|
||
|
|
"""
|
||
|
|
self._on_log = func
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_connect(self):
|
||
|
|
"""If implemented, called when the broker responds to our connection
|
||
|
|
request."""
|
||
|
|
return self._on_connect
|
||
|
|
|
||
|
|
@on_connect.setter
|
||
|
|
def on_connect(self, func):
|
||
|
|
""" Define the connect callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
connect_callback(client, userdata, flags, rc)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
flags: response flags sent by the broker
|
||
|
|
rc: the connection result
|
||
|
|
|
||
|
|
flags is a dict that contains response flags from the broker:
|
||
|
|
flags['session present'] - this flag is useful for clients that are
|
||
|
|
using clean session set to 0 only. If a client with clean
|
||
|
|
session=0, that reconnects to a broker that it has previously
|
||
|
|
connected to, this flag indicates whether the broker still has the
|
||
|
|
session information for the client. If 1, the session still exists.
|
||
|
|
|
||
|
|
The value of rc indicates success or not:
|
||
|
|
0: Connection successful
|
||
|
|
1: Connection refused - incorrect protocol version
|
||
|
|
2: Connection refused - invalid client identifier
|
||
|
|
3: Connection refused - server unavailable
|
||
|
|
4: Connection refused - bad username or password
|
||
|
|
5: Connection refused - not authorised
|
||
|
|
6-255: Currently unused.
|
||
|
|
"""
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_connect = func
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_subscribe(self):
|
||
|
|
"""If implemented, called when the broker responds to a subscribe
|
||
|
|
request."""
|
||
|
|
return self._on_subscribe
|
||
|
|
|
||
|
|
@on_subscribe.setter
|
||
|
|
def on_subscribe(self, func):
|
||
|
|
""" Define the suscribe callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
subscribe_callback(client, userdata, mid, granted_qos)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
mid: matches the mid variable returned from the corresponding
|
||
|
|
subscribe() call.
|
||
|
|
granted_qos: list of integers that give the QoS level the broker has
|
||
|
|
granted for each of the different subscription requests.
|
||
|
|
"""
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_subscribe = func
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_message(self):
|
||
|
|
"""If implemented, called when a message has been received on a topic
|
||
|
|
that the client subscribes to.
|
||
|
|
|
||
|
|
This callback will be called for every message received. Use
|
||
|
|
message_callback_add() to define multiple callbacks that will be called
|
||
|
|
for specific topic filters."""
|
||
|
|
return self._on_message
|
||
|
|
|
||
|
|
@on_message.setter
|
||
|
|
def on_message(self, func):
|
||
|
|
""" Define the message received callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
on_message_callback(client, userdata, message)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
message: an instance of MQTTMessage.
|
||
|
|
This is a class with members topic, payload, qos, retain.
|
||
|
|
"""
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_message = func
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_publish(self):
|
||
|
|
"""If implemented, called when a message that was to be sent using the
|
||
|
|
publish() call has completed transmission to the broker.
|
||
|
|
|
||
|
|
For messages with QoS levels 1 and 2, this means that the appropriate
|
||
|
|
handshakes have completed. For QoS 0, this simply means that the message
|
||
|
|
has left the client.
|
||
|
|
This callback is important because even if the publish() call returns
|
||
|
|
success, it does not always mean that the message has been sent."""
|
||
|
|
return self._on_publish
|
||
|
|
|
||
|
|
@on_publish.setter
|
||
|
|
def on_publish(self, func):
|
||
|
|
""" Define the published message callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
on_publish_callback(client, userdata, mid)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
mid: matches the mid variable returned from the corresponding
|
||
|
|
publish() call, to allow outgoing messages to be tracked.
|
||
|
|
"""
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_publish = func
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_unsubscribe(self):
|
||
|
|
"""If implemented, called when the broker responds to an unsubscribe
|
||
|
|
request."""
|
||
|
|
return self._on_unsubscribe
|
||
|
|
|
||
|
|
@on_unsubscribe.setter
|
||
|
|
def on_unsubscribe(self, func):
|
||
|
|
""" Define the unsubscribe callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
unsubscribe_callback(client, userdata, mid)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
mid: matches the mid variable returned from the corresponding
|
||
|
|
unsubscribe() call.
|
||
|
|
"""
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_unsubscribe = func
|
||
|
|
|
||
|
|
@property
|
||
|
|
def on_disconnect(self):
|
||
|
|
"""If implemented, called when the client disconnects from the broker.
|
||
|
|
"""
|
||
|
|
return self._on_disconnect
|
||
|
|
|
||
|
|
@on_disconnect.setter
|
||
|
|
def on_disconnect(self, func):
|
||
|
|
""" Define the disconnect callback implementation.
|
||
|
|
|
||
|
|
Expected signature is:
|
||
|
|
disconnect_callback(client, userdata, self)
|
||
|
|
|
||
|
|
client: the client instance for this callback
|
||
|
|
userdata: the private user data as set in Client() or userdata_set()
|
||
|
|
rc: the disconnection result
|
||
|
|
The rc parameter indicates the disconnection state. If
|
||
|
|
MQTT_ERR_SUCCESS (0), the callback was called in response to
|
||
|
|
a disconnect() call. If any other value the disconnection
|
||
|
|
was unexpected, such as might be caused by a network error.
|
||
|
|
"""
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_disconnect = func
|
||
|
|
|
||
|
|
def message_callback_add(self, sub, callback):
|
||
|
|
"""Register a message callback for a specific topic.
|
||
|
|
Messages that match 'sub' will be passed to 'callback'. Any
|
||
|
|
non-matching messages will be passed to the default on_message
|
||
|
|
callback.
|
||
|
|
|
||
|
|
Call multiple times with different 'sub' to define multiple topic
|
||
|
|
specific callbacks.
|
||
|
|
|
||
|
|
Topic specific callbacks may be removed with
|
||
|
|
message_callback_remove()."""
|
||
|
|
if callback is None or sub is None:
|
||
|
|
raise ValueError("sub and callback must both be defined.")
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
self._on_message_filtered[sub] = callback
|
||
|
|
|
||
|
|
def message_callback_remove(self, sub):
|
||
|
|
"""Remove a message callback previously registered with
|
||
|
|
message_callback_add()."""
|
||
|
|
if sub is None:
|
||
|
|
raise ValueError("sub must defined.")
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
try:
|
||
|
|
del self._on_message_filtered[sub]
|
||
|
|
except KeyError: # no such subscription
|
||
|
|
pass
|
||
|
|
|
||
|
|
# ============================================================
|
||
|
|
# Private functions
|
||
|
|
# ============================================================
|
||
|
|
|
||
|
|
def _loop_rc_handle(self, rc):
|
||
|
|
if rc:
|
||
|
|
if self._sock:
|
||
|
|
self._sock.close()
|
||
|
|
self._sock = None
|
||
|
|
|
||
|
|
if self._state == mqtt_cs_disconnecting:
|
||
|
|
rc = MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_disconnect:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_disconnect(self, self._userdata, rc)
|
||
|
|
return rc
|
||
|
|
|
||
|
|
def _packet_read(self):
|
||
|
|
# This gets called if pselect() indicates that there is network data
|
||
|
|
# available - ie. at least one byte. What we do depends on what data we
|
||
|
|
# already have.
|
||
|
|
# If we've not got a command, attempt to read one and save it. This should
|
||
|
|
# always work because it's only a single byte.
|
||
|
|
# Then try to read the remaining length. This may fail because it is may
|
||
|
|
# be more than one byte - will need to save data pending next read if it
|
||
|
|
# does fail.
|
||
|
|
# Then try to read the remaining payload, where 'payload' here means the
|
||
|
|
# combined variable header and actual payload. This is the most likely to
|
||
|
|
# fail due to longer length, so save current data and current position.
|
||
|
|
# After all data is read, send to _mqtt_handle_packet() to deal with.
|
||
|
|
# Finally, free the memory and reset everything to starting conditions.
|
||
|
|
if self._in_packet['command'] == 0:
|
||
|
|
try:
|
||
|
|
command = self._sock.recv(1)
|
||
|
|
except socket.error as err:
|
||
|
|
if self._ssl and (err.errno == ssl.SSL_ERROR_WANT_READ or err.errno == ssl.SSL_ERROR_WANT_WRITE):
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
if err.errno == EAGAIN:
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
print(err)
|
||
|
|
return 1
|
||
|
|
else:
|
||
|
|
if len(command) == 0:
|
||
|
|
return 1
|
||
|
|
command, = struct.unpack("!B", command)
|
||
|
|
self._in_packet['command'] = command
|
||
|
|
|
||
|
|
if self._in_packet['have_remaining'] == 0:
|
||
|
|
# Read remaining
|
||
|
|
# Algorithm for decoding taken from pseudo code at
|
||
|
|
# http://publib.boulder.ibm.com/infocenter/wmbhelp/v6r0m0/topic/com.ibm.etools.mft.doc/ac10870_.htm
|
||
|
|
while True:
|
||
|
|
try:
|
||
|
|
byte = self._sock.recv(1)
|
||
|
|
except socket.error as err:
|
||
|
|
if self._ssl and (err.errno == ssl.SSL_ERROR_WANT_READ or err.errno == ssl.SSL_ERROR_WANT_WRITE):
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
if err.errno == EAGAIN:
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
print(err)
|
||
|
|
return 1
|
||
|
|
else:
|
||
|
|
if len(byte) == 0:
|
||
|
|
return 1
|
||
|
|
byte, = struct.unpack("!B", byte)
|
||
|
|
self._in_packet['remaining_count'].append(byte)
|
||
|
|
# Max 4 bytes length for remaining length as defined by protocol.
|
||
|
|
# Anything more likely means a broken/malicious client.
|
||
|
|
if len(self._in_packet['remaining_count']) > 4:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
self._in_packet['remaining_length'] += (byte & 127) * self._in_packet['remaining_mult']
|
||
|
|
self._in_packet['remaining_mult'] = self._in_packet['remaining_mult'] * 128
|
||
|
|
|
||
|
|
if (byte & 128) == 0:
|
||
|
|
break
|
||
|
|
|
||
|
|
self._in_packet['have_remaining'] = 1
|
||
|
|
self._in_packet['to_process'] = self._in_packet['remaining_length']
|
||
|
|
|
||
|
|
while self._in_packet['to_process'] > 0:
|
||
|
|
try:
|
||
|
|
data = self._sock.recv(self._in_packet['to_process'])
|
||
|
|
except socket.error as err:
|
||
|
|
if self._ssl and (err.errno == ssl.SSL_ERROR_WANT_READ or err.errno == ssl.SSL_ERROR_WANT_WRITE):
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
if err.errno == EAGAIN:
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
print(err)
|
||
|
|
return 1
|
||
|
|
else:
|
||
|
|
if len(data) == 0:
|
||
|
|
return 1
|
||
|
|
self._in_packet['to_process'] -= len(data)
|
||
|
|
self._in_packet['packet'] += data
|
||
|
|
|
||
|
|
# All data for this packet is read.
|
||
|
|
self._in_packet['pos'] = 0
|
||
|
|
rc = self._packet_handle()
|
||
|
|
|
||
|
|
# Free data and reset values
|
||
|
|
self._in_packet = {
|
||
|
|
'command': 0,
|
||
|
|
'have_remaining': 0,
|
||
|
|
'remaining_count': [],
|
||
|
|
'remaining_mult': 1,
|
||
|
|
'remaining_length': 0,
|
||
|
|
'packet': b"",
|
||
|
|
'to_process': 0,
|
||
|
|
'pos': 0}
|
||
|
|
|
||
|
|
with self._msgtime_mutex:
|
||
|
|
self._last_msg_in = time_func()
|
||
|
|
return rc
|
||
|
|
|
||
|
|
def _packet_write(self):
|
||
|
|
self._current_out_packet_mutex.acquire()
|
||
|
|
|
||
|
|
while self._current_out_packet:
|
||
|
|
packet = self._current_out_packet
|
||
|
|
|
||
|
|
try:
|
||
|
|
write_length = self._sock.send(packet['packet'][packet['pos']:])
|
||
|
|
except (AttributeError, ValueError):
|
||
|
|
self._current_out_packet_mutex.release()
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
except socket.error as err:
|
||
|
|
self._current_out_packet_mutex.release()
|
||
|
|
if self._ssl and (err.errno == ssl.SSL_ERROR_WANT_READ or err.errno == ssl.SSL_ERROR_WANT_WRITE):
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
if err.errno == EAGAIN:
|
||
|
|
return MQTT_ERR_AGAIN
|
||
|
|
print(err)
|
||
|
|
return 1
|
||
|
|
|
||
|
|
if write_length > 0:
|
||
|
|
packet['to_process'] -= write_length
|
||
|
|
packet['pos'] += write_length
|
||
|
|
|
||
|
|
if packet['to_process'] == 0:
|
||
|
|
if (packet['command'] & 0xF0) == PUBLISH and packet['qos'] == 0:
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_publish:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_publish(self, self._userdata, packet['mid'])
|
||
|
|
|
||
|
|
packet['info']._set_as_published()
|
||
|
|
|
||
|
|
if (packet['command'] & 0xF0) == DISCONNECT:
|
||
|
|
self._current_out_packet_mutex.release()
|
||
|
|
|
||
|
|
with self._msgtime_mutex:
|
||
|
|
self._last_msg_out = time_func()
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_disconnect:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_disconnect(self, self._userdata, 0)
|
||
|
|
|
||
|
|
if self._sock:
|
||
|
|
self._sock.close()
|
||
|
|
self._sock = None
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
with self._out_packet_mutex:
|
||
|
|
if len(self._out_packet) > 0:
|
||
|
|
self._current_out_packet = self._out_packet.popleft()
|
||
|
|
else:
|
||
|
|
self._current_out_packet = None
|
||
|
|
else:
|
||
|
|
break
|
||
|
|
|
||
|
|
self._current_out_packet_mutex.release()
|
||
|
|
|
||
|
|
with self._msgtime_mutex:
|
||
|
|
self._last_msg_out = time_func()
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _easy_log(self, level, fmt, *args):
|
||
|
|
if self.on_log:
|
||
|
|
buf = fmt % args
|
||
|
|
self.on_log(self, self._userdata, level, buf)
|
||
|
|
if self._logger:
|
||
|
|
level_std = LOGGING_LEVEL[level]
|
||
|
|
self._logger.log(level_std, fmt, *args)
|
||
|
|
|
||
|
|
def _check_keepalive(self):
|
||
|
|
if self._keepalive == 0:
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
now = time_func()
|
||
|
|
|
||
|
|
with self._msgtime_mutex:
|
||
|
|
last_msg_out = self._last_msg_out
|
||
|
|
last_msg_in = self._last_msg_in
|
||
|
|
|
||
|
|
if self._sock is not None and (now - last_msg_out >= self._keepalive or now - last_msg_in >= self._keepalive):
|
||
|
|
if self._state == mqtt_cs_connected and self._ping_t == 0:
|
||
|
|
self._send_pingreq()
|
||
|
|
with self._msgtime_mutex:
|
||
|
|
self._last_msg_out = now
|
||
|
|
self._last_msg_in = now
|
||
|
|
else:
|
||
|
|
if self._sock:
|
||
|
|
self._sock.close()
|
||
|
|
self._sock = None
|
||
|
|
|
||
|
|
if self._state == mqtt_cs_disconnecting:
|
||
|
|
rc = MQTT_ERR_SUCCESS
|
||
|
|
else:
|
||
|
|
rc = 1
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_disconnect:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_disconnect(self, self._userdata, rc)
|
||
|
|
|
||
|
|
def _mid_generate(self):
|
||
|
|
self._last_mid += 1
|
||
|
|
if self._last_mid == 65536:
|
||
|
|
self._last_mid = 1
|
||
|
|
return self._last_mid
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _topic_wildcard_len_check(topic):
|
||
|
|
# Search for + or # in a topic. Return MQTT_ERR_INVAL if found.
|
||
|
|
# Also returns MQTT_ERR_INVAL if the topic string is too long.
|
||
|
|
# Returns MQTT_ERR_SUCCESS if everything is fine.
|
||
|
|
if b'+' in topic or b'#' in topic or len(topic) == 0 or len(topic) > 65535:
|
||
|
|
return MQTT_ERR_INVAL
|
||
|
|
else:
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _filter_wildcard_len_check(sub):
|
||
|
|
if (len(sub) == 0 or len(sub) > 65535
|
||
|
|
or any(b'+' in p or b'#' in p for p in sub.split(b'/') if len(p) > 1)
|
||
|
|
or b'#/' in sub):
|
||
|
|
return MQTT_ERR_INVAL
|
||
|
|
else:
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _send_pingreq(self):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending PINGREQ")
|
||
|
|
rc = self._send_simple_command(PINGREQ)
|
||
|
|
if rc == MQTT_ERR_SUCCESS:
|
||
|
|
self._ping_t = time_func()
|
||
|
|
return rc
|
||
|
|
|
||
|
|
def _send_pingresp(self):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending PINGRESP")
|
||
|
|
return self._send_simple_command(PINGRESP)
|
||
|
|
|
||
|
|
def _send_puback(self, mid):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending PUBACK (Mid: %d)", mid)
|
||
|
|
return self._send_command_with_mid(PUBACK, mid, False)
|
||
|
|
|
||
|
|
def _send_pubcomp(self, mid):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending PUBCOMP (Mid: %d)", mid)
|
||
|
|
return self._send_command_with_mid(PUBCOMP, mid, False)
|
||
|
|
|
||
|
|
def _pack_remaining_length(self, packet, remaining_length):
|
||
|
|
remaining_bytes = []
|
||
|
|
while True:
|
||
|
|
byte = remaining_length % 128
|
||
|
|
remaining_length = remaining_length // 128
|
||
|
|
# If there are more digits to encode, set the top bit of this digit
|
||
|
|
if remaining_length > 0:
|
||
|
|
byte |= 0x80
|
||
|
|
|
||
|
|
remaining_bytes.append(byte)
|
||
|
|
packet.append(byte)
|
||
|
|
if remaining_length == 0:
|
||
|
|
# FIXME - this doesn't deal with incorrectly large payloads
|
||
|
|
return packet
|
||
|
|
|
||
|
|
def _pack_str16(self, packet, data):
|
||
|
|
if isinstance(data, unicode):
|
||
|
|
data = data.encode('utf-8')
|
||
|
|
packet.extend(struct.pack("!H", len(data)))
|
||
|
|
packet.extend(data)
|
||
|
|
|
||
|
|
def _send_publish(self, mid, topic, payload=b'', qos=0, retain=False, dup=False, info=None):
|
||
|
|
# we assume that topic and payload are already properly encoded
|
||
|
|
assert not isinstance(topic, unicode) and not isinstance(payload, unicode) and payload is not None
|
||
|
|
|
||
|
|
if self._sock is None:
|
||
|
|
return MQTT_ERR_NO_CONN
|
||
|
|
|
||
|
|
command = PUBLISH | ((dup & 0x1) << 3) | (qos << 1) | retain
|
||
|
|
packet = bytearray()
|
||
|
|
packet.append(command)
|
||
|
|
|
||
|
|
payloadlen = len(payload)
|
||
|
|
remaining_length = 2 + len(topic) + payloadlen
|
||
|
|
|
||
|
|
if payloadlen == 0:
|
||
|
|
self._easy_log(
|
||
|
|
MQTT_LOG_DEBUG,
|
||
|
|
"Sending PUBLISH (d%d, q%d, r%d, m%d), '%s' (NULL payload)",
|
||
|
|
dup, qos, retain, mid, topic
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
self._easy_log(
|
||
|
|
MQTT_LOG_DEBUG,
|
||
|
|
"Sending PUBLISH (d%d, q%d, r%d, m%d), '%s', ... (%d bytes)",
|
||
|
|
dup, qos, retain, mid, topic, payloadlen
|
||
|
|
)
|
||
|
|
|
||
|
|
if qos > 0:
|
||
|
|
# For message id
|
||
|
|
remaining_length += 2
|
||
|
|
|
||
|
|
self._pack_remaining_length(packet, remaining_length)
|
||
|
|
self._pack_str16(packet, topic)
|
||
|
|
|
||
|
|
if qos > 0:
|
||
|
|
# For message id
|
||
|
|
packet.extend(struct.pack("!H", mid))
|
||
|
|
|
||
|
|
packet.extend(payload)
|
||
|
|
|
||
|
|
return self._packet_queue(PUBLISH, packet, mid, qos, info)
|
||
|
|
|
||
|
|
def _send_pubrec(self, mid):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending PUBREC (Mid: %d)", mid)
|
||
|
|
return self._send_command_with_mid(PUBREC, mid, False)
|
||
|
|
|
||
|
|
def _send_pubrel(self, mid, dup=False):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending PUBREL (Mid: %d)", mid)
|
||
|
|
return self._send_command_with_mid(PUBREL | 2, mid, dup)
|
||
|
|
|
||
|
|
def _send_command_with_mid(self, command, mid, dup):
|
||
|
|
# For PUBACK, PUBCOMP, PUBREC, and PUBREL
|
||
|
|
if dup:
|
||
|
|
command |= 0x8
|
||
|
|
|
||
|
|
remaining_length = 2
|
||
|
|
packet = struct.pack('!BBH', command, remaining_length, mid)
|
||
|
|
return self._packet_queue(command, packet, mid, 1)
|
||
|
|
|
||
|
|
def _send_simple_command(self, command):
|
||
|
|
# For DISCONNECT, PINGREQ and PINGRESP
|
||
|
|
remaining_length = 0
|
||
|
|
packet = struct.pack('!BB', command, remaining_length)
|
||
|
|
return self._packet_queue(command, packet, 0, 0)
|
||
|
|
|
||
|
|
def _send_connect(self, keepalive, clean_session):
|
||
|
|
proto_ver = self._protocol
|
||
|
|
protocol = b"MQTT" if proto_ver >= MQTTv311 else b"MQIsdp" # hard-coded UTF-8 encoded string
|
||
|
|
|
||
|
|
remaining_length = 2 + len(protocol) + 1 + 1 + 2 + 2 + len(self._client_id)
|
||
|
|
|
||
|
|
connect_flags = 0
|
||
|
|
if clean_session:
|
||
|
|
connect_flags |= 0x02
|
||
|
|
|
||
|
|
if self._will:
|
||
|
|
remaining_length += 2 + len(self._will_topic) + 2 + len(self._will_payload)
|
||
|
|
connect_flags |= 0x04 | ((self._will_qos & 0x03) << 3) | ((self._will_retain & 0x01) << 5)
|
||
|
|
|
||
|
|
if self._username is not None:
|
||
|
|
remaining_length += 2 + len(self._username)
|
||
|
|
connect_flags |= 0x80
|
||
|
|
if self._password is not None:
|
||
|
|
connect_flags |= 0x40
|
||
|
|
remaining_length += 2 + len(self._password)
|
||
|
|
|
||
|
|
command = CONNECT
|
||
|
|
packet = bytearray()
|
||
|
|
packet.append(command)
|
||
|
|
|
||
|
|
self._pack_remaining_length(packet, remaining_length)
|
||
|
|
packet.extend(struct.pack("!H" + str(len(protocol)) + "sBBH", len(protocol), protocol, proto_ver, connect_flags,
|
||
|
|
keepalive))
|
||
|
|
|
||
|
|
self._pack_str16(packet, self._client_id)
|
||
|
|
|
||
|
|
if self._will:
|
||
|
|
self._pack_str16(packet, self._will_topic)
|
||
|
|
self._pack_str16(packet, self._will_payload)
|
||
|
|
|
||
|
|
if self._username is not None:
|
||
|
|
self._pack_str16(packet, self._username)
|
||
|
|
|
||
|
|
if self._password is not None:
|
||
|
|
self._pack_str16(packet, self._password)
|
||
|
|
|
||
|
|
self._keepalive = keepalive
|
||
|
|
self._easy_log(
|
||
|
|
MQTT_LOG_DEBUG,
|
||
|
|
"Sending CONNECT (u%d, p%d, wr%d, wq%d, wf%d, c%d, k%d) client_id=%s",
|
||
|
|
(connect_flags & 0x80) >> 7,
|
||
|
|
(connect_flags & 0x40) >> 6,
|
||
|
|
(connect_flags & 0x20) >> 5,
|
||
|
|
(connect_flags & 0x18) >> 3,
|
||
|
|
(connect_flags & 0x4) >> 2,
|
||
|
|
(connect_flags & 0x2) >> 1,
|
||
|
|
keepalive,
|
||
|
|
self._client_id
|
||
|
|
)
|
||
|
|
return self._packet_queue(command, packet, 0, 0)
|
||
|
|
|
||
|
|
def _send_disconnect(self):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending DISCONNECT")
|
||
|
|
return self._send_simple_command(DISCONNECT)
|
||
|
|
|
||
|
|
def _send_subscribe(self, dup, topics):
|
||
|
|
remaining_length = 2
|
||
|
|
for t, _ in topics:
|
||
|
|
remaining_length += 2 + len(t) + 1
|
||
|
|
|
||
|
|
command = SUBSCRIBE | (dup << 3) | 0x2
|
||
|
|
packet = bytearray()
|
||
|
|
packet.append(command)
|
||
|
|
self._pack_remaining_length(packet, remaining_length)
|
||
|
|
local_mid = self._mid_generate()
|
||
|
|
packet.extend(struct.pack("!H", local_mid))
|
||
|
|
for t, q in topics:
|
||
|
|
self._pack_str16(packet, t)
|
||
|
|
packet.append(q)
|
||
|
|
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending SUBSCRIBE (d%d) %s", dup, topics)
|
||
|
|
return (self._packet_queue(command, packet, local_mid, 1), local_mid)
|
||
|
|
|
||
|
|
def _send_unsubscribe(self, dup, topics):
|
||
|
|
remaining_length = 2
|
||
|
|
for t in topics:
|
||
|
|
remaining_length += 2 + len(t)
|
||
|
|
|
||
|
|
command = UNSUBSCRIBE | (dup << 3) | 0x2
|
||
|
|
packet = bytearray()
|
||
|
|
packet.append(command)
|
||
|
|
self._pack_remaining_length(packet, remaining_length)
|
||
|
|
local_mid = self._mid_generate()
|
||
|
|
packet.extend(struct.pack("!H", local_mid))
|
||
|
|
for t in topics:
|
||
|
|
self._pack_str16(packet, t)
|
||
|
|
|
||
|
|
# topics_repr = ", ".join("'"+topic.decode('utf8')+"'" for topic in topics)
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Sending UNSUBSCRIBE (d%d) %s", dup, topics)
|
||
|
|
return (self._packet_queue(command, packet, local_mid, 1), local_mid)
|
||
|
|
|
||
|
|
def _message_retry_check_actual(self, messages, mutex):
|
||
|
|
with mutex:
|
||
|
|
now = time_func()
|
||
|
|
for m in messages:
|
||
|
|
if m.timestamp + self._message_retry < now:
|
||
|
|
if m.state == mqtt_ms_wait_for_puback or m.state == mqtt_ms_wait_for_pubrec:
|
||
|
|
m.timestamp = now
|
||
|
|
m.dup = True
|
||
|
|
self._send_publish(
|
||
|
|
m.mid,
|
||
|
|
m.topic.encode('utf-8'),
|
||
|
|
m.payload,
|
||
|
|
m.qos,
|
||
|
|
m.retain,
|
||
|
|
m.dup
|
||
|
|
)
|
||
|
|
elif m.state == mqtt_ms_wait_for_pubrel:
|
||
|
|
m.timestamp = now
|
||
|
|
m.dup = True
|
||
|
|
self._send_pubrec(m.mid)
|
||
|
|
elif m.state == mqtt_ms_wait_for_pubcomp:
|
||
|
|
m.timestamp = now
|
||
|
|
m.dup = True
|
||
|
|
self._send_pubrel(m.mid, True)
|
||
|
|
|
||
|
|
def _message_retry_check(self):
|
||
|
|
self._message_retry_check_actual(self._out_messages, self._out_message_mutex)
|
||
|
|
self._message_retry_check_actual(self._in_messages, self._in_message_mutex)
|
||
|
|
|
||
|
|
def _messages_reconnect_reset_out(self):
|
||
|
|
with self._out_message_mutex:
|
||
|
|
self._inflight_messages = 0
|
||
|
|
for m in self._out_messages:
|
||
|
|
m.timestamp = 0
|
||
|
|
if self._max_inflight_messages == 0 or self._inflight_messages < self._max_inflight_messages:
|
||
|
|
if m.qos == 0:
|
||
|
|
m.state = mqtt_ms_publish
|
||
|
|
elif m.qos == 1:
|
||
|
|
# self._inflight_messages = self._inflight_messages + 1
|
||
|
|
if m.state == mqtt_ms_wait_for_puback:
|
||
|
|
m.dup = True
|
||
|
|
m.state = mqtt_ms_publish
|
||
|
|
elif m.qos == 2:
|
||
|
|
# self._inflight_messages = self._inflight_messages + 1
|
||
|
|
if m.state == mqtt_ms_wait_for_pubcomp:
|
||
|
|
m.state = mqtt_ms_resend_pubrel
|
||
|
|
m.dup = True
|
||
|
|
else:
|
||
|
|
if m.state == mqtt_ms_wait_for_pubrec:
|
||
|
|
m.dup = True
|
||
|
|
m.state = mqtt_ms_publish
|
||
|
|
else:
|
||
|
|
m.state = mqtt_ms_queued
|
||
|
|
|
||
|
|
def _messages_reconnect_reset_in(self):
|
||
|
|
with self._in_message_mutex:
|
||
|
|
for m in self._in_messages:
|
||
|
|
m.timestamp = 0
|
||
|
|
if m.qos != 2:
|
||
|
|
self._in_messages.pop(self._in_messages.index(m))
|
||
|
|
else:
|
||
|
|
# Preserve current state
|
||
|
|
pass
|
||
|
|
|
||
|
|
def _messages_reconnect_reset(self):
|
||
|
|
self._messages_reconnect_reset_out()
|
||
|
|
self._messages_reconnect_reset_in()
|
||
|
|
|
||
|
|
def _packet_queue(self, command, packet, mid, qos, info=None):
|
||
|
|
mpkt = {
|
||
|
|
'command': command,
|
||
|
|
'mid': mid,
|
||
|
|
'qos': qos,
|
||
|
|
'pos': 0,
|
||
|
|
'to_process': len(packet),
|
||
|
|
'packet': packet,
|
||
|
|
'info': info}
|
||
|
|
|
||
|
|
with self._out_packet_mutex:
|
||
|
|
self._out_packet.append(mpkt)
|
||
|
|
if self._current_out_packet_mutex.acquire(False):
|
||
|
|
if self._current_out_packet is None and len(self._out_packet) > 0:
|
||
|
|
self._current_out_packet = self._out_packet.popleft()
|
||
|
|
self._current_out_packet_mutex.release()
|
||
|
|
|
||
|
|
# Write a single byte to sockpairW (connected to sockpairR) to break
|
||
|
|
# out of select() if in threaded mode.
|
||
|
|
try:
|
||
|
|
self._sockpairW.send(sockpair_data)
|
||
|
|
except socket.error as err:
|
||
|
|
if err.errno != EAGAIN:
|
||
|
|
raise
|
||
|
|
|
||
|
|
if self._thread is None:
|
||
|
|
if self._in_callback.acquire(False):
|
||
|
|
self._in_callback.release()
|
||
|
|
return self.loop_write()
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _packet_handle(self):
|
||
|
|
cmd = self._in_packet['command'] & 0xF0
|
||
|
|
if cmd == PINGREQ:
|
||
|
|
return self._handle_pingreq()
|
||
|
|
elif cmd == PINGRESP:
|
||
|
|
return self._handle_pingresp()
|
||
|
|
elif cmd == PUBACK:
|
||
|
|
return self._handle_pubackcomp("PUBACK")
|
||
|
|
elif cmd == PUBCOMP:
|
||
|
|
return self._handle_pubackcomp("PUBCOMP")
|
||
|
|
elif cmd == PUBLISH:
|
||
|
|
return self._handle_publish()
|
||
|
|
elif cmd == PUBREC:
|
||
|
|
return self._handle_pubrec()
|
||
|
|
elif cmd == PUBREL:
|
||
|
|
return self._handle_pubrel()
|
||
|
|
elif cmd == CONNACK:
|
||
|
|
return self._handle_connack()
|
||
|
|
elif cmd == SUBACK:
|
||
|
|
return self._handle_suback()
|
||
|
|
elif cmd == UNSUBACK:
|
||
|
|
return self._handle_unsuback()
|
||
|
|
else:
|
||
|
|
# If we don't recognise the command, return an error straight away.
|
||
|
|
self._easy_log(MQTT_LOG_ERR, "Error: Unrecognised command %s", cmd)
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
def _handle_pingreq(self):
|
||
|
|
if self._in_packet['remaining_length'] != 0:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received PINGREQ")
|
||
|
|
return self._send_pingresp()
|
||
|
|
|
||
|
|
def _handle_pingresp(self):
|
||
|
|
if self._in_packet['remaining_length'] != 0:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
# No longer waiting for a PINGRESP.
|
||
|
|
self._ping_t = 0
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received PINGRESP")
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _handle_connack(self):
|
||
|
|
if self._in_packet['remaining_length'] != 2:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
(flags, result) = struct.unpack("!BB", self._in_packet['packet'])
|
||
|
|
if result == CONNACK_REFUSED_PROTOCOL_VERSION and self._protocol == MQTTv311:
|
||
|
|
self._easy_log(
|
||
|
|
MQTT_LOG_DEBUG,
|
||
|
|
"Received CONNACK (%s, %s), attempting downgrade to MQTT v3.1.",
|
||
|
|
flags, result
|
||
|
|
)
|
||
|
|
# Downgrade to MQTT v3.1
|
||
|
|
self._protocol = MQTTv31
|
||
|
|
return self.reconnect()
|
||
|
|
elif (result == CONNACK_REFUSED_IDENTIFIER_REJECTED
|
||
|
|
and self._client_id == b''):
|
||
|
|
self._easy_log(
|
||
|
|
MQTT_LOG_DEBUG,
|
||
|
|
"Received CONNACK (%s, %s), attempting to use non-empty CID",
|
||
|
|
flags, result,
|
||
|
|
)
|
||
|
|
self._client_id = base62(uuid.uuid4().int, padding=22)
|
||
|
|
return self.reconnect()
|
||
|
|
|
||
|
|
if result == 0:
|
||
|
|
self._state = mqtt_cs_connected
|
||
|
|
self._reconnect_delay = None
|
||
|
|
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received CONNACK (%s, %s)", flags, result)
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_connect:
|
||
|
|
flags_dict = {}
|
||
|
|
flags_dict['session present'] = flags & 0x01
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_connect(self, self._userdata, flags_dict, result)
|
||
|
|
|
||
|
|
if result == 0:
|
||
|
|
rc = 0
|
||
|
|
with self._out_message_mutex:
|
||
|
|
for m in self._out_messages:
|
||
|
|
m.timestamp = time_func()
|
||
|
|
if m.state == mqtt_ms_queued:
|
||
|
|
self.loop_write() # Process outgoing messages that have just been queued up
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
if m.qos == 0:
|
||
|
|
with self._in_callback: # Don't call loop_write after _send_publish()
|
||
|
|
rc = self._send_publish(
|
||
|
|
m.mid,
|
||
|
|
m.topic.encode('utf-8'),
|
||
|
|
m.payload,
|
||
|
|
m.qos,
|
||
|
|
m.retain,
|
||
|
|
m.dup,
|
||
|
|
)
|
||
|
|
if rc != 0:
|
||
|
|
return rc
|
||
|
|
elif m.qos == 1:
|
||
|
|
if m.state == mqtt_ms_publish:
|
||
|
|
self._inflight_messages += 1
|
||
|
|
m.state = mqtt_ms_wait_for_puback
|
||
|
|
with self._in_callback: # Don't call loop_write after _send_publish()
|
||
|
|
rc = self._send_publish(
|
||
|
|
m.mid,
|
||
|
|
m.topic.encode('utf-8'),
|
||
|
|
m.payload,
|
||
|
|
m.qos,
|
||
|
|
m.retain,
|
||
|
|
m.dup,
|
||
|
|
)
|
||
|
|
if rc != 0:
|
||
|
|
return rc
|
||
|
|
elif m.qos == 2:
|
||
|
|
if m.state == mqtt_ms_publish:
|
||
|
|
self._inflight_messages += 1
|
||
|
|
m.state = mqtt_ms_wait_for_pubrec
|
||
|
|
with self._in_callback: # Don't call loop_write after _send_publish()
|
||
|
|
rc = self._send_publish(
|
||
|
|
m.mid,
|
||
|
|
m.topic.encode('utf-8'),
|
||
|
|
m.payload,
|
||
|
|
m.qos,
|
||
|
|
m.retain,
|
||
|
|
m.dup,
|
||
|
|
)
|
||
|
|
if rc != 0:
|
||
|
|
return rc
|
||
|
|
elif m.state == mqtt_ms_resend_pubrel:
|
||
|
|
self._inflight_messages += 1
|
||
|
|
m.state = mqtt_ms_wait_for_pubcomp
|
||
|
|
with self._in_callback: # Don't call loop_write after _send_publish()
|
||
|
|
rc = self._send_pubrel(m.mid, m.dup)
|
||
|
|
if rc != 0:
|
||
|
|
return rc
|
||
|
|
self.loop_write() # Process outgoing messages that have just been queued up
|
||
|
|
|
||
|
|
return rc
|
||
|
|
elif result > 0 and result < 6:
|
||
|
|
return MQTT_ERR_CONN_REFUSED
|
||
|
|
else:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
def _handle_suback(self):
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received SUBACK")
|
||
|
|
pack_format = "!H" + str(len(self._in_packet['packet']) - 2) + 's'
|
||
|
|
(mid, packet) = struct.unpack(pack_format, self._in_packet['packet'])
|
||
|
|
pack_format = "!" + "B" * len(packet)
|
||
|
|
granted_qos = struct.unpack(pack_format, packet)
|
||
|
|
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_subscribe:
|
||
|
|
with self._in_callback: # Don't call loop_write after _send_publish()
|
||
|
|
self.on_subscribe(self, self._userdata, mid, granted_qos)
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _handle_publish(self):
|
||
|
|
rc = 0
|
||
|
|
|
||
|
|
header = self._in_packet['command']
|
||
|
|
message = MQTTMessage()
|
||
|
|
message.dup = (header & 0x08) >> 3
|
||
|
|
message.qos = (header & 0x06) >> 1
|
||
|
|
message.retain = (header & 0x01)
|
||
|
|
|
||
|
|
pack_format = "!H" + str(len(self._in_packet['packet']) - 2) + 's'
|
||
|
|
(slen, packet) = struct.unpack(pack_format, self._in_packet['packet'])
|
||
|
|
pack_format = '!' + str(slen) + 's' + str(len(packet) - slen) + 's'
|
||
|
|
(topic, packet) = struct.unpack(pack_format, packet)
|
||
|
|
|
||
|
|
if len(topic) == 0:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
# Handle topics with invalid UTF-8
|
||
|
|
# This replaces an invalid topic with a message and the hex
|
||
|
|
# representation of the topic for logging. When the user attempts to
|
||
|
|
# access message.topic in the callback, an exception will be raised.
|
||
|
|
if sys.version_info[0] >= 3:
|
||
|
|
try:
|
||
|
|
print_topic = topic.decode('utf-8')
|
||
|
|
except UnicodeDecodeError:
|
||
|
|
print_topic = "TOPIC WITH INVALID UTF-8: " + str(topic)
|
||
|
|
else:
|
||
|
|
print_topic = topic
|
||
|
|
|
||
|
|
message.topic = topic
|
||
|
|
|
||
|
|
if message.qos > 0:
|
||
|
|
pack_format = "!H" + str(len(packet) - 2) + 's'
|
||
|
|
(message.mid, packet) = struct.unpack(pack_format, packet)
|
||
|
|
|
||
|
|
message.payload = packet
|
||
|
|
|
||
|
|
self._easy_log(
|
||
|
|
MQTT_LOG_DEBUG,
|
||
|
|
"Received PUBLISH (d%d, q%d, r%d, m%d), '%s', ... (%d bytes)",
|
||
|
|
message.dup, message.qos, message.retain, message.mid,
|
||
|
|
print_topic, len(message.payload)
|
||
|
|
)
|
||
|
|
|
||
|
|
message.timestamp = time_func()
|
||
|
|
if message.qos == 0:
|
||
|
|
self._handle_on_message(message)
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
elif message.qos == 1:
|
||
|
|
rc = self._send_puback(message.mid)
|
||
|
|
self._handle_on_message(message)
|
||
|
|
return rc
|
||
|
|
elif message.qos == 2:
|
||
|
|
rc = self._send_pubrec(message.mid)
|
||
|
|
message.state = mqtt_ms_wait_for_pubrel
|
||
|
|
with self._in_message_mutex:
|
||
|
|
if message not in self._in_messages:
|
||
|
|
self._in_messages.append(message)
|
||
|
|
return rc
|
||
|
|
else:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
def _handle_pubrel(self):
|
||
|
|
if self._in_packet['remaining_length'] != 2:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
mid, = struct.unpack("!H", self._in_packet['packet'])
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received PUBREL (Mid: %d)", mid)
|
||
|
|
|
||
|
|
with self._in_message_mutex:
|
||
|
|
for i in range(len(self._in_messages)):
|
||
|
|
if self._in_messages[i].mid == mid:
|
||
|
|
|
||
|
|
# Only pass the message on if we have removed it from the queue - this
|
||
|
|
# prevents multiple callbacks for the same message.
|
||
|
|
self._handle_on_message(self._in_messages[i])
|
||
|
|
self._in_messages.pop(i)
|
||
|
|
self._inflight_messages -= 1
|
||
|
|
if self._max_inflight_messages > 0:
|
||
|
|
with self._out_message_mutex:
|
||
|
|
rc = self._update_inflight()
|
||
|
|
if rc != MQTT_ERR_SUCCESS:
|
||
|
|
return rc
|
||
|
|
|
||
|
|
return self._send_pubcomp(mid)
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _update_inflight(self):
|
||
|
|
# Dont lock message_mutex here
|
||
|
|
for m in self._out_messages:
|
||
|
|
if self._inflight_messages < self._max_inflight_messages:
|
||
|
|
if m.qos > 0 and m.state == mqtt_ms_queued:
|
||
|
|
self._inflight_messages += 1
|
||
|
|
if m.qos == 1:
|
||
|
|
m.state = mqtt_ms_wait_for_puback
|
||
|
|
elif m.qos == 2:
|
||
|
|
m.state = mqtt_ms_wait_for_pubrec
|
||
|
|
rc = self._send_publish(
|
||
|
|
m.mid,
|
||
|
|
m.topic.encode('utf-8'),
|
||
|
|
m.payload,
|
||
|
|
m.qos,
|
||
|
|
m.retain,
|
||
|
|
m.dup,
|
||
|
|
)
|
||
|
|
if rc != 0:
|
||
|
|
return rc
|
||
|
|
else:
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _handle_pubrec(self):
|
||
|
|
if self._in_packet['remaining_length'] != 2:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
mid, = struct.unpack("!H", self._in_packet['packet'])
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received PUBREC (Mid: %d)", mid)
|
||
|
|
|
||
|
|
with self._out_message_mutex:
|
||
|
|
for m in self._out_messages:
|
||
|
|
if m.mid == mid:
|
||
|
|
m.state = mqtt_ms_wait_for_pubcomp
|
||
|
|
m.timestamp = time_func()
|
||
|
|
return self._send_pubrel(mid, False)
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _handle_unsuback(self):
|
||
|
|
if self._in_packet['remaining_length'] != 2:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
mid, = struct.unpack("!H", self._in_packet['packet'])
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received UNSUBACK (Mid: %d)", mid)
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_unsubscribe:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_unsubscribe(self, self._userdata, mid)
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _do_on_publish(self, idx, mid):
|
||
|
|
with self._callback_mutex:
|
||
|
|
if self.on_publish:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_publish(self, self._userdata, mid)
|
||
|
|
|
||
|
|
msg = self._out_messages.pop(idx)
|
||
|
|
if msg.qos > 0:
|
||
|
|
self._inflight_messages -= 1
|
||
|
|
if self._max_inflight_messages > 0:
|
||
|
|
rc = self._update_inflight()
|
||
|
|
if rc != MQTT_ERR_SUCCESS:
|
||
|
|
return rc
|
||
|
|
msg.info._set_as_published()
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _handle_pubackcomp(self, cmd):
|
||
|
|
if self._in_packet['remaining_length'] != 2:
|
||
|
|
return MQTT_ERR_PROTOCOL
|
||
|
|
|
||
|
|
mid, = struct.unpack("!H", self._in_packet['packet'])
|
||
|
|
self._easy_log(MQTT_LOG_DEBUG, "Received %s (Mid: %d)", cmd, mid)
|
||
|
|
|
||
|
|
with self._out_message_mutex:
|
||
|
|
for i in range(len(self._out_messages)):
|
||
|
|
try:
|
||
|
|
if self._out_messages[i].mid == mid:
|
||
|
|
# Only inform the client the message has been sent once.
|
||
|
|
rc = self._do_on_publish(i, mid)
|
||
|
|
return rc
|
||
|
|
except IndexError:
|
||
|
|
# Have removed item so i>count.
|
||
|
|
# Not really an error.
|
||
|
|
pass
|
||
|
|
|
||
|
|
return MQTT_ERR_SUCCESS
|
||
|
|
|
||
|
|
def _handle_on_message(self, message):
|
||
|
|
matched = False
|
||
|
|
with self._callback_mutex:
|
||
|
|
try:
|
||
|
|
topic = message.topic
|
||
|
|
except UnicodeDecodeError:
|
||
|
|
topic = None
|
||
|
|
|
||
|
|
if topic is not None:
|
||
|
|
for callback in self._on_message_filtered.iter_match(message.topic):
|
||
|
|
with self._in_callback:
|
||
|
|
callback(self, self._userdata, message)
|
||
|
|
matched = True
|
||
|
|
|
||
|
|
if matched == False and self.on_message:
|
||
|
|
with self._in_callback:
|
||
|
|
self.on_message(self, self._userdata, message)
|
||
|
|
|
||
|
|
def _thread_main(self):
|
||
|
|
self.loop_forever(retry_first_connection=True)
|
||
|
|
|
||
|
|
def _reconnect_wait(self):
|
||
|
|
# See reconnect_delay_set for details
|
||
|
|
now = time_func()
|
||
|
|
with self._reconnect_delay_mutex:
|
||
|
|
if self._reconnect_delay is None:
|
||
|
|
self._reconnect_delay = self._reconnect_min_delay
|
||
|
|
else:
|
||
|
|
self._reconnect_delay = min(
|
||
|
|
self._reconnect_delay * 2,
|
||
|
|
self._reconnect_max_delay,
|
||
|
|
)
|
||
|
|
|
||
|
|
target_time = now + self._reconnect_delay
|
||
|
|
|
||
|
|
remaining = target_time - now
|
||
|
|
while (self._state != mqtt_cs_disconnecting
|
||
|
|
and not self._thread_terminate
|
||
|
|
and remaining > 0):
|
||
|
|
|
||
|
|
time.sleep(min(remaining, 1))
|
||
|
|
remaining = target_time - time_func()
|
||
|
|
|
||
|
|
|
||
|
|
# Compatibility class for easy porting from mosquitto.py.
|
||
|
|
class Mosquitto(Client):
|
||
|
|
def __init__(self, client_id="", clean_session=True, userdata=None):
|
||
|
|
super(Mosquitto, self).__init__(client_id, clean_session, userdata)
|
||
|
|
|
||
|
|
|
||
|
|
class WebsocketWrapper(object):
|
||
|
|
OPCODE_CONTINUATION = 0x0
|
||
|
|
OPCODE_TEXT = 0x1
|
||
|
|
OPCODE_BINARY = 0x2
|
||
|
|
OPCODE_CONNCLOSE = 0x8
|
||
|
|
OPCODE_PING = 0x9
|
||
|
|
OPCODE_PONG = 0xa
|
||
|
|
|
||
|
|
def __init__(self, socket, host, port, is_ssl, path, extra_headers):
|
||
|
|
|
||
|
|
self.connected = False
|
||
|
|
|
||
|
|
self._ssl = is_ssl
|
||
|
|
self._host = host
|
||
|
|
self._port = port
|
||
|
|
self._socket = socket
|
||
|
|
self._path = path
|
||
|
|
|
||
|
|
self._sendbuffer = bytearray()
|
||
|
|
self._readbuffer = bytearray()
|
||
|
|
|
||
|
|
self._requested_size = 0
|
||
|
|
self._payload_head = 0
|
||
|
|
self._readbuffer_head = 0
|
||
|
|
|
||
|
|
self._do_handshake(extra_headers)
|
||
|
|
|
||
|
|
def __del__(self):
|
||
|
|
|
||
|
|
self._sendbuffer = None
|
||
|
|
self._readbuffer = None
|
||
|
|
|
||
|
|
def _do_handshake(self, extra_headers):
|
||
|
|
|
||
|
|
sec_websocket_key = uuid.uuid4().bytes
|
||
|
|
sec_websocket_key = base64.b64encode(sec_websocket_key)
|
||
|
|
|
||
|
|
websocket_headers = {
|
||
|
|
"Host": "{self._host:s}:{self._port:d}".format(self=self),
|
||
|
|
"Upgrade": "websocket",
|
||
|
|
"Connection": "Upgrade",
|
||
|
|
"Origin": "https://{self._host:s}:{self._port:d}".format(self=self),
|
||
|
|
"Sec-WebSocket-Key": sec_websocket_key.decode("utf8"),
|
||
|
|
"Sec-Websocket-Version": "13",
|
||
|
|
"Sec-Websocket-Protocol": "mqtt",
|
||
|
|
}
|
||
|
|
|
||
|
|
# This is checked in ws_set_options so it will either be None, a
|
||
|
|
# dictionary, or a callable
|
||
|
|
if isinstance(extra_headers, dict):
|
||
|
|
websocket_headers.update(extra_headers)
|
||
|
|
elif callable(extra_headers):
|
||
|
|
websocket_headers = extra_headers(websocket_headers)
|
||
|
|
|
||
|
|
header = "\r\n".join([
|
||
|
|
"GET {self._path} HTTP/1.1".format(self=self),
|
||
|
|
"\r\n".join("{}: {}".format(i, j) for i, j in websocket_headers.items()),
|
||
|
|
"\r\n",
|
||
|
|
]).encode("utf8")
|
||
|
|
|
||
|
|
self._socket.send(header)
|
||
|
|
|
||
|
|
has_secret = False
|
||
|
|
has_upgrade = False
|
||
|
|
|
||
|
|
while True:
|
||
|
|
# read HTTP response header as lines
|
||
|
|
byte = self._socket.recv(1)
|
||
|
|
|
||
|
|
self._readbuffer.extend(byte)
|
||
|
|
|
||
|
|
# line end
|
||
|
|
if byte == b"\n":
|
||
|
|
if len(self._readbuffer) > 2:
|
||
|
|
# check upgrade
|
||
|
|
if b"connection" in str(self._readbuffer).lower().encode('utf-8'):
|
||
|
|
if b"upgrade" not in str(self._readbuffer).lower().encode('utf-8'):
|
||
|
|
raise WebsocketConnectionError("WebSocket handshake error, connection not upgraded")
|
||
|
|
else:
|
||
|
|
has_upgrade = True
|
||
|
|
|
||
|
|
# check key hash
|
||
|
|
if b"sec-websocket-accept" in str(self._readbuffer).lower().encode('utf-8'):
|
||
|
|
GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||
|
|
|
||
|
|
server_hash = self._readbuffer.decode('utf-8').split(": ", 1)[1]
|
||
|
|
server_hash = server_hash.strip().encode('utf-8')
|
||
|
|
|
||
|
|
client_hash = sec_websocket_key.decode('utf-8') + GUID
|
||
|
|
client_hash = hashlib.sha1(client_hash.encode('utf-8'))
|
||
|
|
client_hash = base64.b64encode(client_hash.digest())
|
||
|
|
|
||
|
|
if server_hash != client_hash:
|
||
|
|
raise WebsocketConnectionError("WebSocket handshake error, invalid secret key")
|
||
|
|
else:
|
||
|
|
has_secret = True
|
||
|
|
else:
|
||
|
|
# ending linebreak
|
||
|
|
break
|
||
|
|
|
||
|
|
# reset linebuffer
|
||
|
|
self._readbuffer = bytearray()
|
||
|
|
|
||
|
|
# connection reset
|
||
|
|
elif not byte:
|
||
|
|
raise WebsocketConnectionError("WebSocket handshake error")
|
||
|
|
|
||
|
|
if not has_upgrade or not has_secret:
|
||
|
|
raise WebsocketConnectionError("WebSocket handshake error")
|
||
|
|
|
||
|
|
self._readbuffer = bytearray()
|
||
|
|
self.connected = True
|
||
|
|
|
||
|
|
def _create_frame(self, opcode, data, do_masking=1):
|
||
|
|
|
||
|
|
header = bytearray()
|
||
|
|
length = len(data)
|
||
|
|
mask_key = bytearray(
|
||
|
|
[random.randint(0, 255), random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)])
|
||
|
|
mask_flag = do_masking
|
||
|
|
|
||
|
|
# 1 << 7 is the final flag, we don't send continuated data
|
||
|
|
header.append(1 << 7 | opcode)
|
||
|
|
|
||
|
|
if length < 126:
|
||
|
|
header.append(mask_flag << 7 | length)
|
||
|
|
|
||
|
|
elif length < 32768:
|
||
|
|
header.append(mask_flag << 7 | 126)
|
||
|
|
header += struct.pack("!H", length)
|
||
|
|
|
||
|
|
elif length < 0x8000000000000001:
|
||
|
|
header.append(mask_flag << 7 | 127)
|
||
|
|
header += struct.pack("!Q", length)
|
||
|
|
|
||
|
|
else:
|
||
|
|
raise ValueError("Maximum payload size is 2^63")
|
||
|
|
|
||
|
|
if mask_flag == 1:
|
||
|
|
for index in range(length):
|
||
|
|
data[index] ^= mask_key[index % 4]
|
||
|
|
data = mask_key + data
|
||
|
|
|
||
|
|
return header + data
|
||
|
|
|
||
|
|
def _buffered_read(self, length):
|
||
|
|
|
||
|
|
# try to recv and strore needed bytes
|
||
|
|
wanted_bytes = length - (len(self._readbuffer) - self._readbuffer_head)
|
||
|
|
if wanted_bytes > 0:
|
||
|
|
|
||
|
|
data = self._socket.recv(wanted_bytes)
|
||
|
|
|
||
|
|
if not data:
|
||
|
|
raise socket.error(errno.ECONNABORTED, 0)
|
||
|
|
else:
|
||
|
|
self._readbuffer.extend(data)
|
||
|
|
|
||
|
|
if len(data) < wanted_bytes:
|
||
|
|
raise socket.error(errno.EAGAIN, 0)
|
||
|
|
|
||
|
|
self._readbuffer_head += length
|
||
|
|
return self._readbuffer[self._readbuffer_head - length:self._readbuffer_head]
|
||
|
|
|
||
|
|
def _recv_impl(self, length):
|
||
|
|
|
||
|
|
# try to decode websocket payload part from data
|
||
|
|
try:
|
||
|
|
|
||
|
|
self._readbuffer_head = 0
|
||
|
|
|
||
|
|
result = None
|
||
|
|
|
||
|
|
chunk_startindex = self._payload_head
|
||
|
|
chunk_endindex = self._payload_head + length
|
||
|
|
|
||
|
|
header1 = self._buffered_read(1)
|
||
|
|
header2 = self._buffered_read(1)
|
||
|
|
|
||
|
|
opcode = (header1[0] & 0x0f)
|
||
|
|
maskbit = (header2[0] & 0x80) == 0x80
|
||
|
|
lengthbits = (header2[0] & 0x7f)
|
||
|
|
payload_length = lengthbits
|
||
|
|
mask_key = None
|
||
|
|
|
||
|
|
# read length
|
||
|
|
if lengthbits == 0x7e:
|
||
|
|
|
||
|
|
value = self._buffered_read(2)
|
||
|
|
payload_length, = struct.unpack("!H", value)
|
||
|
|
|
||
|
|
elif lengthbits == 0x7f:
|
||
|
|
|
||
|
|
value = self._buffered_read(8)
|
||
|
|
payload_length, = struct.unpack("!Q", value)
|
||
|
|
|
||
|
|
# read mask
|
||
|
|
if maskbit:
|
||
|
|
mask_key = self._buffered_read(4)
|
||
|
|
|
||
|
|
# if frame payload is shorter than the requested data, read only the possible part
|
||
|
|
readindex = chunk_endindex
|
||
|
|
if payload_length < readindex:
|
||
|
|
readindex = payload_length
|
||
|
|
|
||
|
|
if readindex > 0:
|
||
|
|
# get payload chunk
|
||
|
|
payload = self._buffered_read(readindex)
|
||
|
|
|
||
|
|
# unmask only the needed part
|
||
|
|
if maskbit:
|
||
|
|
for index in range(chunk_startindex, readindex):
|
||
|
|
payload[index] ^= mask_key[index % 4]
|
||
|
|
|
||
|
|
result = payload[chunk_startindex:readindex]
|
||
|
|
self._payload_head = readindex
|
||
|
|
else:
|
||
|
|
payload = bytearray()
|
||
|
|
|
||
|
|
# check if full frame arrived and reset readbuffer and payloadhead if needed
|
||
|
|
if readindex == payload_length:
|
||
|
|
self._readbuffer = bytearray()
|
||
|
|
self._payload_head = 0
|
||
|
|
|
||
|
|
# respond to non-binary opcodes, their arrival is not guaranteed beacause of non-blocking sockets
|
||
|
|
if opcode == WebsocketWrapper.OPCODE_CONNCLOSE:
|
||
|
|
frame = self._create_frame(WebsocketWrapper.OPCODE_CONNCLOSE, payload, 0)
|
||
|
|
self._socket.send(frame)
|
||
|
|
|
||
|
|
if opcode == WebsocketWrapper.OPCODE_PING:
|
||
|
|
frame = self._create_frame(WebsocketWrapper.OPCODE_PONG, payload, 0)
|
||
|
|
self._socket.send(frame)
|
||
|
|
|
||
|
|
if opcode == WebsocketWrapper.OPCODE_BINARY:
|
||
|
|
return result
|
||
|
|
else:
|
||
|
|
raise socket.error(errno.EAGAIN, 0)
|
||
|
|
|
||
|
|
except socket.error as err:
|
||
|
|
|
||
|
|
if err.errno == errno.ECONNABORTED:
|
||
|
|
self.connected = False
|
||
|
|
return b''
|
||
|
|
else:
|
||
|
|
# no more data
|
||
|
|
raise
|
||
|
|
|
||
|
|
def _send_impl(self, data):
|
||
|
|
|
||
|
|
# if previous frame was sent successfully
|
||
|
|
if len(self._sendbuffer) == 0:
|
||
|
|
# create websocket frame
|
||
|
|
frame = self._create_frame(WebsocketWrapper.OPCODE_BINARY, bytearray(data))
|
||
|
|
self._sendbuffer.extend(frame)
|
||
|
|
self._requested_size = len(data)
|
||
|
|
|
||
|
|
# try to write out as much as possible
|
||
|
|
length = self._socket.send(self._sendbuffer)
|
||
|
|
|
||
|
|
self._sendbuffer = self._sendbuffer[length:]
|
||
|
|
|
||
|
|
if len(self._sendbuffer) == 0:
|
||
|
|
# buffer sent out completely, return with payload's size
|
||
|
|
return self._requested_size
|
||
|
|
else:
|
||
|
|
# couldn't send whole data, request the same data again with 0 as sent length
|
||
|
|
return 0
|
||
|
|
|
||
|
|
def recv(self, length):
|
||
|
|
return self._recv_impl(length)
|
||
|
|
|
||
|
|
def read(self, length):
|
||
|
|
return self._recv_impl(length)
|
||
|
|
|
||
|
|
def send(self, data):
|
||
|
|
return self._send_impl(data)
|
||
|
|
|
||
|
|
def write(self, data):
|
||
|
|
return self._send_impl(data)
|
||
|
|
|
||
|
|
def close(self):
|
||
|
|
self._socket.close()
|
||
|
|
|
||
|
|
def fileno(self):
|
||
|
|
return self._socket.fileno()
|
||
|
|
|
||
|
|
def pending(self):
|
||
|
|
# Fix for bug #131: a SSL socket may still have data available
|
||
|
|
# for reading without select() being aware of it.
|
||
|
|
if self._ssl:
|
||
|
|
return self._socket.pending()
|
||
|
|
else:
|
||
|
|
# normal socket rely only on select()
|
||
|
|
return 0
|
||
|
|
|
||
|
|
def setblocking(self, flag):
|
||
|
|
self._socket.setblocking(flag)
|