async def initialize_telematics_connection(self): will_message = gmqtt.Message( config.TELEMATICS_MQTT_APPLICATION_ALERTS_TOPIC, "Unexpected Exit.", will_delay_interval=10, qos=1, retain=True, ) self.telematics_client = gmqtt.Client( client_id="{}-{}".format(self.__class__.__name__, self.telematics_application_id), clean_session=True, optimistic_acknowledgement=True, will_message=will_message, ) Telematics._assign_callbacks_to_client_telematics( self.telematics_client) if self.telematics_auth_token: self.telematics_client.set_auth_credentials( self.telematics_auth_token, None) await self.telematics_client.connect( self.telematics_broker_host, self.telematics_port, ssl=self.telematics_ssl_enabled, version=MQTTv311, raise_exc=True, keepalive=60, )
async def main(broker_host, broker_port, token): # create client instance, kwargs (session expiry interval and maximum packet size) # will be send as properties in connect packet sub_client = gmqtt.Client("clientgonnasub", session_expiry_interval=600, maximum_packet_size=65535) assign_callbacks_to_client(sub_client) sub_client.set_auth_credentials(token, None) await sub_client.connect(broker_host, broker_port) # two overlapping subscriptions with different subscription identifiers sub_client.subscribe('TEST/PROPS/#', qos=1, subscription_identifier=1) sub_client.subscribe('TEST/#', qos=0, subscription_identifier=2) pub_client = gmqtt.Client("clientgonnapub") assign_callbacks_to_client(pub_client) pub_client.set_auth_credentials(token, None) await pub_client.connect(broker_host, broker_port) # this message received by sub_client will have two subscription identifiers pub_client.publish('TEST/PROPS/42', '42 is the answer', qos=1, content_type='utf-8', message_expiry_interval=60, user_property=('time', str(time.time()))) # just another way to publish same message msg = gmqtt.Message('TEST/PROPS/42', '42 is the answer', qos=1, content_type='utf-8', message_expiry_interval=60, user_property=('time', str(time.time()))) pub_client.publish(msg) pub_client.publish('TEST/42', {42: 'is the answer'}, qos=1, content_type='json', message_expiry_interval=60, user_property=('time', str(time.time()))) await STOP.wait() await pub_client.disconnect() await sub_client.disconnect(session_expiry_interval=0)
async def main(broker_host, broker_port, token): # this message will be published by broker after client disconnects with "bad" code after 10 sec will_message = gmqtt.Message('TEST/WILL/42', "I'm dead finally", will_delay_interval=10) will_client = gmqtt.Client("clientgonnadie", will_message=will_message) assign_callbacks_to_client(will_client) will_client.set_auth_credentials(token, None) await will_client.connect(broker_host, broker_port) another_client = gmqtt.Client("clientgonnalisten") assign_callbacks_to_client(another_client) another_client.set_auth_credentials(token, None) await another_client.connect(broker_host, broker_port) another_client.subscribe('TEST/#') # reason code 4 - Disconnect with Will Message await will_client.disconnect(reason_code=4, reason_string="Smth went wrong") await STOP.wait() await another_client.disconnect()
async def test_will_message(init_clients): aclient, callback, bclient, callback2 = init_clients # re-initialize aclient with will message will_message = gmqtt.Message(TOPICS[2], "I'm dead finally") aclient = gmqtt.Client("myclientid3", clean_session=True, will_message=will_message) aclient.set_auth_credentials(username) await aclient.connect(host, port=port) await bclient.connect(host=host, port=port) bclient.subscribe(TOPICS[2]) await asyncio.sleep(1) await aclient.disconnect(reason_code=4) await asyncio.sleep(1) assert len(callback2.messages) == 1
async def main(broker_host, token): will_message = gmqtt.Message(WORKER_UNREGISTER_TOPIC, worker.worker_hex, will_delay_interval=2) client = gmqtt.Client(f'worker-{worker.worker_hex}', will_message=will_message) client = await init_client(client, broker_host, token, on_message=on_message) client.publish(WORKER_REGISTRATION_TOPIC, worker.worker_hex, qos=1) client.subscribe(WORKER_REGISTRED_TOPIC, qos=1) await STOP.wait() await client.disconnect(reason_code=4 ) # reason code 4 - disconnect with Will Message
async def main(broker_host): will_message = gmqtt.Message(status_topic, msg_dead, retain=True, will_delay_interval=will_delay) client = gmqtt.Client(client_id, will_message=will_message) assign_callbacks_to_client(client) await client.connect(broker_host) print('Publish message indicating current status...') client.publish(status_topic, msg_on, retain=True) print('Subscribe topic to receive request messages...') client.subscribe(teds_topic, no_local=True) await STOP.wait() client.publish(status_topic, msg_off, retain=True) await client.disconnect()
def define_mqtt_client(self, client_id): will_message = gmqtt.Message( "brokers/{}/alerts/service/{}/disconnected".format( client_id, self.__class__.__name__ ), "Unexpected Exit.", will_delay_interval=10, qos=1, retain=False, ) self.mqtt_client = gmqtt.Client( client_id=client_id, clean_session=True, optimistic_acknowledgement=True, will_message=will_message, ) self.mqtt_client.on_connect = self.on_connect self.mqtt_client.on_message = self.on_message self.mqtt_client.on_disconnect = self.on_disconnect self.mqtt_client.on_subscribe = self.on_subscribe