def on_message(client: mqtt.Client, user_data, message: mqtt.MQTTMessage) -> None:
"""
:param client: mqtt.Client instance for this callback
:param user_data: the private user data as set in mqtt.Client() or mqtt.Client.user_data_set()
:param message: mqtt.MQTTMessage object
:return:
"""
msg = Message(message.payload)
if msg.error:
msg.payload = 'Message error.'
client.queue.put(msg)
def on_disconnect(client: mqtt.Client, user_data, return_code: int) -> None:
"""
:param client: mqtt.Client instance for this callback
:param user_data: the private user data as set in mqtt.Client() or mqtt.Client.user_data_set()
:param return_code:
:return:
"""
if return_code != 0:
msg = Message.status_message('Disconnected unexpectedly.')
else:
msg = Message.status_message('Disconnected.')
client.queue.put(msg)
def test_bad_unicode() -> None:
empty = b''
bad = Message(empty)
assert bad.error is True
malformed = b'{"id": "123"'
bad = Message(malformed)
assert bad.error is True
unicode_msg = ''
bad = Message(unicode_msg)
assert bad.error is True
unicode_msg = 'bob\'s burgers are people'
bad = Message(unicode_msg)
assert bad.error is True
def start_connection(host, port, action, value):
addr = (host, port)
log.info(f'starting connection to {addr}')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.connect_ex(addr)
events = selectors.EVENT_READ | selectors.EVENT_WRITE
message = Message(sel, sock, addr, filemanager, action, value)
sel.register(sock, events, data=message)
def on_subscribe(client: mqtt.Client, user_data, message_id: int, granted_qos) -> None:
"""
:type client: mqtt.Client instance for this callback
:param user_data: the private user data as set in mqtt.Client() or mqtt.Client.user_data_set()
:param message_id: integer, the message id
:param granted_qos:
:return:
"""
status = Message.status_message('Subscription active.')
client.queue.put(status)
def publish(self, message: str, message_id: int) -> None:
"""
Publishes payload to broker
:param message: string
:param message_id: integer.
:return: mqtt.MQTTMessageInfo
"""
payload: str = self._create_payload(message, message_id)
max_payload_bytes = 268435455
if size(payload) > max_payload_bytes:
msg = Message.status_message('Message too large.')
self.client.queue.put(msg)
return
return_value: mqtt.MQTTMessageInfo = self.client.publish(self.client.topic, payload, qos=2)
if return_value.rc == 0: # Publication successful
return
else:
raise SubscriptionError(f'MQTTMessageInfo error code: {return_value.rc}')
def on_connect(client: mqtt.Client, user_data, flags: Dict, return_code: int) -> None:
"""
:type client: mqtt.Client instance for this callback
:param user_data: the private user data as set in mqtt.Client() or mqtt.Client.user_data_set()
:param flags: response flags sent by broker
:param return_code: int, indicates whether connection was successful or not.
They are:
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.
:return: None
"""
if return_code != 0:
if return_code == 1:
raise SubscriptionError('Incorrect protocol version')
elif return_code == 2:
raise SubscriptionError('Invalid client identifier')
elif return_code == 3:
raise SubscriptionError('Server unavailable')
elif return_code == 4:
raise SubscriptionError('Bad username or password')
elif return_code == 5:
raise SubscriptionError('Not authorized')
else:
raise SubscriptionError(f'Non-specified connection error code: {return_code}')
# If the message queue is not added correctly the the client instance, than messages
# cannot be correctly passed
if not isinstance(client.queue, queue.Queue):
raise SubscriptionError('Queue absent from instance. Aborting.')
if client.topic is None or not isinstance(client.topic, str) or len(client.topic) == 0:
raise SubscriptionError('Topic absent from instance. Aborting.')
client.subscribe(client.topic, qos=2)
status = Message.status_message('Connected.')
client.queue.put(status)
def test_good() -> None:
good_message = b'{"id": "123", "timestamp": "123456", "payload": "light on"}'
good = Message(good_message)
assert good.error is False
assert good.get_error_text() == "No errors."
def test_class_method() -> None:
text = 'Testing'
msg = Message.status_message(text)
assert msg.error is False
assert msg.get_error_text() == 'No errors.'
assert msg.payload == 'Testing'
def test_missing_payload() -> None:
missing_payload = b'{"id": "123", "timestamp": "123456"}'
bad = Message(missing_payload)
assert bad.error is True
def test_missing_id() -> None:
missing_id = b'{"timestamp": "123456", "payload": "light on"}'
bad = Message(missing_id)
assert bad.error is True
def test_missing_ts() -> None:
missing_ts = b'{"id": "123", "payload": "light on"}'
bad = Message(missing_ts)
assert bad.error is True