async def mqtt_record(server: str, output: str = None, append: bool = False) -> None: """Record MQTT messages""" mqtt = MQTTClient() await mqtt.connect(server) await mqtt.subscribe(TOPICS) if (output is not None and append is False): output_file = open(output, 'wt') output_file.close() while True: message = await mqtt.deliver_message() if output is not None: output_file = open(output, 'a+') else: output_file = sys.stdout record = { 'time': time.time(), 'qos': message.qos, 'retain': message.retain, 'topic': message.topic, 'msg_b64': base64.urlsafe_b64encode(message.data).decode() } print(json.dumps(record), file=output_file) if output is not None: output_file.close() logger.debug(json.dumps(record))
async def main(color, value, topic): """Starter """ sub_topic = 'hb/{}'.format(topic) mqtt = MQTTClient() await mqtt.connect('mqtt://localhost') await mqtt.subscribe([(sub_topic, QOS_1)]) leds = cmd.Leds() setattr(leds, color, value) await mqtt.publish(topic, ns.marshall(leds)) try: while True: message = await mqtt.deliver_message() payload = message.publish_packet.payload.data if ns.is_protobuf(payload): obj = ns.unmarshall(payload) if ns.is_ack(obj): break else: LOG.debug(">> %s", payload) await mqtt.unsubscribe([sub_topic]) await mqtt.disconnect() except ClientException as cli_exc: LOG.error("Client exception: %s", cli_exc)
async def mqtt_replay(server: str, input: str = None, delay: int = 0, realtime: bool = False, scale: float = 1, repeat: bool = False) -> None: """Replay MQTT messages""" mqtt = MQTTClient() await mqtt.connect(server) await mqtt.subscribe(TOPICS) if input is not None: input_file = open(input, 'rt') else: input_file = sys.stdin if delay > 0: static_delay_s = delay / 1000 else: static_delay_s = 0 last_timestamp = None if repeat: while True: await process_input_file(input_file, last_timestamp, mqtt, realtime, scale, static_delay_s) if input is not None: input_file = open(input, 'rt') else: await process_input_file(input_file, last_timestamp, mqtt, realtime, scale, static_delay_s)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) sub_client = MQTTClient() yield from sub_client.connect('mqtt://localhost', cleansession=False) ret = yield from sub_client.subscribe([('/qos0', QOS_0), ('/qos1', QOS_1), ('/qos2', QOS_2)]) self.assertEquals(ret, [QOS_0, QOS_1, QOS_2]) yield from sub_client.disconnect() yield from asyncio.sleep(0.1) yield from self._client_publish('/qos0', b'data', QOS_0, retain=True) yield from self._client_publish('/qos1', b'data', QOS_1, retain=True) yield from self._client_publish('/qos2', b'data', QOS_2, retain=True) yield from sub_client.reconnect() for qos in [QOS_0, QOS_1, QOS_2]: log.debug("TEST QOS: %d" % qos) message = yield from sub_client.deliver_message() log.debug("Message: " + repr(message.publish_packet)) self.assertIsNotNone(message) self.assertEquals(message.topic, '/qos%s' % qos) self.assertEquals(message.data, b'data') self.assertEquals(message.qos, qos) yield from sub_client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
async def emulate(args: argparse.Namespace) -> None: """Run broker and client and publish values.""" # Parse data into a dict mqtt_data = {} with open(args.filename, "rt") as fp: for line in fp: item_topic, item_payload = line.strip().split(",", 1) mqtt_data[item_topic] = json.loads(item_payload) # Run Broker broker = Broker(BROKER_CONFIG) await broker.start() # Run Client client = MQTTClient() await client.connect("mqtt://localhost") # Publish all topics from the provided dump file for topic, data in mqtt_data.items(): payload = json.dumps(data).encode() await client.publish(topic, payload, retain=True) # Subscribe to command topic and start listening for commands await client.subscribe([("OpenZWave/1/command/#", QOS_0)]) try: await process_messages(client, mqtt_data) except asyncio.CancelledError: await client.disconnect() broker.shutdown()
def main(): if sys.version_info[:2] < (3, 4): logger.fatal("Error: Python 3.4+ is required") sys.exit(-1) config = None config = read_yaml_config(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'default_client.yaml')) logger.debug("Using default configuration") loop = asyncio.get_event_loop() client_id = "mqtt_publisher_exp" client = MQTTClient(client_id=client_id, config=config, loop=loop) try: logger.info("%s Connecting to broker" % client.client_id) loop.run_until_complete(client.connect(uri=BROKER_URL)) qos = QOS_1 topic = "topic_1" for _, row in data.iterrows(): row['TIMING_client_request_timestamp'] = time() message = row.to_json().encode(encoding='utf-8') logger.info("%s Publishing to '%s'" % (client.client_id, topic)) loop.run_until_complete(client.publish(topic, message, qos)) sleep(0.1) except KeyboardInterrupt: loop.run_until_complete(client.disconnect()) logger.info("%s Disconnected from broker" % client.client_id) except ConnectException as ce: logger.fatal("connection to '%s' failed: %r" % (BROKER_URL, ce)) except asyncio.CancelledError as cae: logger.fatal("Publish canceled due to prvious error")
def _connect(self): """MQTT connection helper function.""" config = self._build_client_config() self._log(logging.DEBUG, "MQTT client ID: {}".format(self._client_id)) self._log(logging.DEBUG, "MQTT client config: {}".format(config)) hbmqtt_client = MQTTClient(client_id=self._client_id, config=config) self._log( logging.INFO, "Connecting MQTT client to broker: {}".format(self._broker_url)) ack_con = yield hbmqtt_client.connect(self._broker_url, cleansession=False) if ack_con != MQTTCodesACK.CON_OK: raise ConnectException( "Error code in connection ACK: {}".format(ack_con)) if self._mqtt_handler.topics: self._log(logging.DEBUG, "Subscribing to: {}".format(self._mqtt_handler.topics)) ack_sub = yield hbmqtt_client.subscribe(self._mqtt_handler.topics) if MQTTCodesACK.SUB_ERROR in ack_sub: raise ConnectException( "Error code in subscription ACK: {}".format(ack_sub)) self._client = hbmqtt_client
async def test_client_subscribe_twice(broker, mock_plugin_manager): client = MQTTClient() ret = await client.connect("mqtt://127.0.0.1/") assert ret == 0 await client.subscribe([("/topic", QOS_0)]) # Test if the client test client subscription is registered assert "/topic" in broker._subscriptions subs = broker._subscriptions["/topic"] assert len(subs) == 1 (s, qos) = subs[0] assert s == client.session assert qos == QOS_0 await client.subscribe([("/topic", QOS_0)]) assert len(subs) == 1 (s, qos) = subs[0] assert s == client.session assert qos == QOS_0 await client.disconnect() await asyncio.sleep(0.1) mock_plugin_manager.assert_has_calls( [ call().fire_event( EVENT_BROKER_CLIENT_SUBSCRIBED, client_id=client.session.client_id, topic="/topic", qos=QOS_0, ) ], any_order=True, )
async def start(self): self._client = MQTTClient(config={'reconnect_retries': 500}) try: await self._client.connect('mqtt://%s:%s/' % (self._hostname, self._port)) except ClientException as ce: logger.error("Client exception: %s" % ce)
def uptime_coro(): try: while True: C = MQTTClient() yield from C.connect('mqtt://127.0.0.1:8080') # Subscribe to '$SYS/broker/uptime' with QOS=1 yield from C.subscribe([ ('bd/#', QOS_1), ]) logger.info("Subscribed") message = yield from C.deliver_message() packet = message.publish_packet get_request = packet.payload.data header = packet.variable_header.topic_name.split('/') if get_request == b'bot': print("%d: %s => %s" % (1, packet.variable_header.topic_name, str)) db_maybe.bot_session(C, packet.variable_header.topic_name, packet.payload.data) if header[1] == 'two': print("%d: %s => %s" % (1, packet.variable_header.topic_name, str)) db_maybe.two_players_session(C, packet.variable_header.topic_name, packet.payload.data) yield from C.unsubscribe(['$SYS/broker/uptime', '$SYS/broker/load/#']) logger.info("UnSubscribed") yield from C.disconnect() except ClientException as ce: logger.error("Client exception: %s" % ce) yield from C.unsubscribe(['$SYS/broker/uptime', '$SYS/broker/load/#']) logger.info("UnSubscribed") yield from C.disconnect()
async def start_helper_bot(self): try: if self.Client is None: self.Client = MQTTClient(client_id=self.client_id, config={"check_hostname": False}) await self.Client.connect( "mqtts://{}:{}/".format(self.address[0], self.address[1]), cafile=bumper.ca_cert, ) await self.Client.subscribe([ ("iot/p2p/+/+/+/+/helper1/bumper/helper1/+/+/+", QOS_0), ("iot/p2p/+", QOS_0), ("iot/atr/+", QOS_0), ]) asyncio.create_task(self.get_msg()) except ConnectionRefusedError as e: helperbotlog.Error(e) pass except asyncio.CancelledError as e: pass except hbmqtt.client.ConnectException as e: helperbotlog.Error(e) pass except Exception as e: helperbotlog.exception("{}".format(e))
def __init__(self,cbpi): self.config = { 'listeners': { 'default': { 'type': 'tcp', 'bind': '0.0.0.0:1885', }, 'ws': { 'bind': '0.0.0.0:8081', 'type': 'ws' } }, 'sys_interval': 10, 'topic-check': { 'enabled': True, 'plugins': [ 'topic_taboo' ] }, 'auth': { 'allow-anonymous': True, 'password-file': '/Users/manuelfritsch/github/aio_sample.cbpi/user.txt' } } self.cbpi = cbpi self.broker = Broker(self.config, plugin_namespace="hbmqtt.broker.plugins") self.client = MQTTClient() self.matcher = MQTTMatcher() self.mqtt_methods = {"test": self.ok_msg, "$SYS/broker/#": self.sysmsg} self.cbpi.app.on_startup.append(self.start_broker) self.count = 0
def _client_publish(self, topic, data, qos, retain=False): pub_client = MQTTClient() ret = yield from pub_client.connect('mqtt://127.0.0.1/') self.assertEqual(ret, 0) ret = yield from pub_client.publish(topic, data, qos, retain) yield from pub_client.disconnect() return ret
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) client = MQTTClient() ret = yield from client.connect('mqtt://127.0.0.1/') self.assertEqual(ret, 0) self.assertIn(client.session.client_id, broker._sessions) yield from client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) self.assertDictEqual(broker._sessions, {}) MockPluginManager.assert_has_calls([ call().fire_event(EVENT_BROKER_CLIENT_CONNECTED, client_id=client.session.client_id), call().fire_event(EVENT_BROKER_CLIENT_DISCONNECTED, client_id=client.session.client_id) ], any_order=True) future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) sub_client = MQTTClient() yield from sub_client.connect('mqtt://127.0.0.1') ret = yield from sub_client.subscribe([('/qos0', QOS_0), ('/qos1', QOS_1), ('/qos2', QOS_2)]) self.assertEqual(ret, [QOS_0, QOS_1, QOS_2]) yield from self._client_publish('/qos0', b'data', QOS_0) yield from self._client_publish('/qos1', b'data', QOS_1) yield from self._client_publish('/qos2', b'data', QOS_2) yield from asyncio.sleep(0.1) for qos in [QOS_0, QOS_1, QOS_2]: message = yield from sub_client.deliver_message() self.assertIsNotNone(message) self.assertEqual(message.topic, '/qos%s' % qos) self.assertEqual(message.data, b'data') self.assertEqual(message.qos, qos) yield from sub_client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) sub_client = MQTTClient() yield from sub_client.connect('mqtt://127.0.0.1') ret = yield from sub_client.subscribe([('+/monitor/Clients', QOS_0)]) self.assertEqual(ret, [QOS_0]) yield from self._client_publish('/test/monitor/Clients', b'data', QOS_0) message = yield from sub_client.deliver_message() self.assertIsNotNone(message) yield from self._client_publish('$SYS/monitor/Clients', b'data', QOS_0) yield from asyncio.sleep(0.1) message = None try: message = yield from sub_client.deliver_message(timeout=2) except Exception as e: pass self.assertIsNone(message) yield from sub_client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) pub_client = MQTTClient() ret = yield from pub_client.connect('mqtt://127.0.0.1/') self.assertEqual(ret, 0) yield from pub_client.publish('/topic', b'data', QOS_0, retain=True) yield from pub_client.disconnect() yield from asyncio.sleep(0.1) self.assertIn('/topic', broker._retained_messages) retained_message = broker._retained_messages['/topic'] self.assertEqual(retained_message.source_session, pub_client.session) self.assertEqual(retained_message.topic, '/topic') self.assertEqual(retained_message.data, b'data') self.assertEqual(retained_message.qos, QOS_0) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) pub_client = MQTTClient() ret = yield from pub_client.connect('mqtt://127.0.0.1/') self.assertEqual(ret, 0) ret_message = yield from pub_client.publish( '/topic', bytearray(b'\x99' * 256 * 1024), QOS_2) yield from pub_client.disconnect() self.assertEqual(broker._retained_messages, {}) yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) MockPluginManager.assert_has_calls([ call().fire_event(EVENT_BROKER_MESSAGE_RECEIVED, client_id=pub_client.session.client_id, message=ret_message), ], any_order=True) future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) client = MQTTClient() ret = yield from client.connect('mqtt://127.0.0.1/') self.assertEqual(ret, 0) yield from client.subscribe([('/topic', QOS_0)]) # Test if the client test client subscription is registered self.assertIn('/topic', broker._subscriptions) subs = broker._subscriptions['/topic'] self.assertEqual(len(subs), 1) (s, qos) = subs[0] self.assertEqual(s, client.session) self.assertEqual(qos, QOS_0) yield from client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) MockPluginManager.assert_has_calls([ call().fire_event(EVENT_BROKER_CLIENT_SUBSCRIBED, client_id=client.session.client_id, topic='/topic', qos=QOS_0) ], any_order=True) future.set_result(True) except Exception as ae: future.set_exception(ae)
async def test_client_publish_retain_delete(broker): pub_client = MQTTClient() ret = await pub_client.connect("mqtt://127.0.0.1/") assert ret == 0 await pub_client.publish("/topic", b"", QOS_0, retain=True) await pub_client.disconnect() await asyncio.sleep(0.1) assert "/topic" not in broker._retained_messages
def __init__(self, config): self.config = config self.client = MQTTClient( client_id=config.mqtt_client_id, config={ 'keep_alive': config.mqtt_keep_alive, }, )
async def __aenter__(self): self._cli = MQTTClient(client_id=self._client_id) with ir_path("eufy_security.mqtt", "eufy.crt") as crt: await self._cli.connect( f"mqtts://{self._username}:{self._password}@security-mqtt.eufylife.com:8789", cafile=str(crt)) await self._cli.subscribe([(self._topic, QOS_1)]) return self
def __init__(self, on_message_cb, port=MQTT_PORT, max_time=MAX_TIME): # on_message_cb = send_to_broker method in gateway application self._on_message_cb = on_message_cb self.port = port self.max_time = max_time self.nodes = {} self.mqtt_client = MQTTClient() asyncio.get_event_loop().create_task(self.start())
async def test_connect_ws(): broker = Broker(broker_config, plugin_namespace="hbmqtt.test.plugins") await broker.start() client = MQTTClient() await client.connect("ws://127.0.0.1:8080/") assert client.session is not None await client.disconnect() await broker.shutdown()
def __init__(self, pin, ipAddress, networkId, asyncio_loop): self.loop = asyncio_loop self.pin = pin self.networkId = networkId self.ipAddress = ipAddress self.topic = 'devices/io-expander/{id}/digital-input/{pin}'.format( id=self.networkId, pin=self.pin) self.client = MQTTClient()
async def test_coro(): try: client = MQTTClient() await client.connect("mqtt://test.mosquitto.org/") self.assertIsNotNone(client.session) await client.disconnect() future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: client = MQTTClient() yield from client.connect('mqtt://test.mosquitto.org/') self.assertIsNotNone(client.session) yield from client.disconnect() future.set_result(True) except Exception as ae: future.set_exception(ae)
def publisher(): C = MQTTClient() ret = C.connect('mqtt://127.0.0.1:1883/') message = C.publish('/slack_in', b'TEST MESSAGE WITH QOS_0', qos=QOS_0) message = C.publish('/slack_in', b'TEST MESSAGE WITH QOS_1', qos=QOS_1) message = C.publish('/slack_in', b'TEST MESSAGE WITH QOS_2', qos=QOS_2) print(message) print("messages published") C.disconnect()
async def pool(n, url): clients = [MQTTClient() for _ in range(n)] try: await asyncio.gather(*[client.connect(url) for client in clients]) yield clients except ConnectException: logging.exception(f"Could not connect to {url}") finally: await asyncio.gather(*[client.disconnect() for client in clients])
async def connect(url): client = MQTTClient() try: await client.connect(url) yield client except ConnectException: logging.exception(f"Could not connect to {url}") finally: await client.disconnect()