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(): # prettify json messages and clear base64 image data if "MetaData" in data and "ProductPicBase64" in data["MetaData"]: data["MetaData"]["ProductPicBase64"] = "" payload = json.dumps(data, indent=4).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()
class MQTTBroker(object): """Encapsulates an embedded MQTT broker.""" def __init__(self, host, port): """Initialize a new instance.""" from hbmqtt.broker import Broker self._loop = asyncio.new_event_loop() hbmqtt_config = { 'listeners': { 'default': { 'max-connections': 50000, 'type': 'tcp', 'bind': '{}:{}'.format(host, port) } }, 'auth': { 'plugins': ['auth.anonymous'], 'allow-anonymous': True } } self._broker = Broker(config=hbmqtt_config, loop=self._loop) self._thread = threading.Thread(target=self._run_loop) self._started_ev = threading.Event() def start(self): """Start the broker.""" self._thread.start() self._started_ev.wait() def stop(self): """Stop the broker.""" self._loop.call_soon_threadsafe(asyncio.async, self._broker.shutdown()) self._loop.call_soon_threadsafe(self._loop.stop) self._thread.join() def _run_loop(self): """Run the loop.""" asyncio.set_event_loop(self._loop) self._loop.run_until_complete(self._broker_coroutine()) self._started_ev.set() self._loop.run_forever() self._loop.close() @asyncio.coroutine def _broker_coroutine(self): """The Broker coroutine.""" yield from self._broker.start()
class HbmqttRunner(RunnerSupport): """Hbmqtt broker runner""" def __init__(self): super().__init__('hbmqtt') self.broker = None async def run_coro(self): self.broker = Broker(self.config) await self.broker.start() async def term_coro(self): if self.broker: self.broker.shutdown() self.broker = None
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://localhost/') 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()) 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()) sub_client = MQTTClient() yield from sub_client.connect('mqtt://localhost') 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://localhost') 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) 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://localhost/') 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()) 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.subscribe([('/topic', QOS_0)]) 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)
def main(*args, **kwargs): if sys.version_info[:2] < (3, 4): logger.fatal("Error: Python 3.4+ is required") sys.exit(-1) arguments = docopt(__doc__, version=get_version()) formatter = "[%(asctime)s] :: %(levelname)s - %(message)s" if arguments['-d']: level = logging.DEBUG else: level = logging.INFO logging.basicConfig(level=level, format=formatter) config = None if arguments['-c']: config = read_yaml_config(arguments['-c']) else: config = read_yaml_config(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'default_broker.yaml')) logger.debug("Using default configuration") loop = asyncio.get_event_loop() broker = Broker(config) try: loop.run_until_complete(broker.start()) loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(broker.shutdown()) finally: loop.close()
def main(*args, **kwargs): if sys.version_info[:2] < (3, 4): logger.fatal("Error: Python 3.4+ is required") sys.exit(-1) arguments = docopt(__doc__, version=get_version()) formatter = "[%(asctime)s] :: %(levelname)s - %(message)s" #debug mode if arguments['-d']: level = logging.DEBUG else: level = logging.INFO logging.basicConfig(level=level, format=formatter) config = None if arguments['-c']: config = read_yaml_config(arguments['-c']) else: config = read_yaml_config( os.path.join(os.path.dirname(os.path.realpath(__file__)), 'config.yaml')) logger.debug("Using default configuration") loop = asyncio.get_event_loop() #啟動broker broker = Broker(config) try: loop.run_until_complete(broker.start()) loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(broker.shutdown()) finally: loop.close()
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://localhost/') 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()) sub_client = MQTTClient() yield from sub_client.connect('mqtt://127.0.0.1', cleansession=False) 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 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.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 main(*args, **kwargs): if sys.version_info[:2] < (3, 4): logger.fatal("Error: Python 3.4+ is required") sys.exit(-1) formatter = "[%(asctime)s] :: %(levelname)s - %(message)s" level = logging.INFO logging.basicConfig(level=level, format=formatter) config = read_yaml_config( os.path.join(os.path.dirname(os.path.realpath(__file__)), 'broker_config.yaml')) logger.debug("Using default configuration") print(config) loop = asyncio.get_event_loop() broker = Broker(config) try: loop.run_until_complete(broker.start()) loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(broker.shutdown()) finally: loop.close()
def test_coro(): try: broker = Broker(broker_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() client = MQTTClient() yield from client.connect('mqtt://127.0.0.1/') self.assertIsNotNone(client.session) ret = yield from client.subscribe([ ('test_topic', QOS_0), ]) self.assertEqual(ret[0], QOS_0) client_pub = MQTTClient() yield from client_pub.connect('mqtt://127.0.0.1/') yield from client_pub.publish('test_topic', data, QOS_0) yield from client_pub.disconnect() message = yield from client.deliver_message() self.assertIsNotNone(message) self.assertIsNotNone(message.publish_packet) self.assertEqual(message.data, data) yield from client.unsubscribe(['$SYS/broker/uptime']) yield from client.disconnect() yield from broker.shutdown() 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://localhost/') 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)
def test_coro(): try: broker = Broker(broker_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() client = MQTTClient() yield from client.connect('ws://127.0.0.1:8080/') self.assertIsNotNone(client.session) yield from client.disconnect() yield from broker.shutdown() future.set_result(True) except Exception as ae: future.set_exception(ae)
class MQTTBroker(object): """Encapsulates an embedded MQTT broker.""" def __init__(self, host, port): """Initialize a new instance.""" from hbmqtt.broker import Broker self._loop = asyncio.new_event_loop() hbmqtt_config = { 'listeners': { 'default': { 'max-connections': 50000, 'type': 'tcp', 'bind': '{}:{}'.format(host, port) } }, 'auth': { 'plugins': ['auth.anonymous'], 'allow-anonymous': True } } self._broker = Broker(config=hbmqtt_config, loop=self._loop) self._thread = threading.Thread(target=self._run_loop) self._started_ev = threading.Event() def start(self): """Start the broker.""" self._thread.start() self._started_ev.wait() def stop(self): """Stop the broker.""" self._loop.call_soon_threadsafe(asyncio. async, self._broker.shutdown()) self._loop.call_soon_threadsafe(self._loop.stop) self._thread.join() def _run_loop(self): """Run the loop.""" asyncio.set_event_loop(self._loop) self._loop.run_until_complete(self._broker_coroutine()) self._started_ev.set() self._loop.run_forever() self._loop.close() @asyncio.coroutine def _broker_coroutine(self): """The Broker coroutine.""" yield from self._broker.start()
def test_coro(): try: broker = Broker(broker_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() client = MQTTClient() ca = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'mosquitto.org.crt') yield from client.connect('ws://127.0.0.1:8081/', cafile=ca) self.assertIsNotNone(client.session) yield from client.disconnect() yield from broker.shutdown() future.set_result(True) except Exception as ae: future.set_exception(ae)
class ParentMain(Parent): @asyncio.coroutine def broker_coro(self): yield from self.broker.start() def __init__(self, config): super().__init__(config) self.broker = Broker(config_broker) asyncio.get_event_loop().run_until_complete(self.broker_coro()) #asyncio.get_event_loop().run_forever() th = threading.Thread(target=asyncio.get_event_loop().run_forever) th.setDaemon(True) th.start() def read(self, params=None): super().read(params) def write(self, value, params=None): super().write(value, params) def __del__(self): super().__del__() self.broker.shutdown()
def run(self) -> None: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) broker = Broker(config=self._config) try: loop.run_until_complete(broker.start()) self.logger.info('Starting local MQTT message broker ...') loop.run_forever() except BrokerException as e: self.logger.critical(e) except KeyboardInterrupt: loop.run_until_complete(broker.shutdown()) finally: loop.close()
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) conn_reader, conn_writer = \ yield from asyncio.open_connection('127.0.0.1', 1883, loop=self.loop) reader = StreamReaderAdapter(conn_reader) writer = StreamWriterAdapter(conn_writer) vh = ConnectVariableHeader() payload = ConnectPayload() vh.keep_alive = 10 vh.clean_session_flag = False vh.will_retain_flag = False payload.client_id = 'test_id' connect = ConnectPacket(vh=vh, payload=payload) yield from connect.to_stream(writer) yield from ConnackPacket.from_stream(reader) publish_1 = PublishPacket.build('/test', b'data', 1, False, QOS_2, False) yield from publish_1.to_stream(writer) asyncio.ensure_future(PubrecPacket.from_stream(reader), loop=self.loop) yield from asyncio.sleep(2) publish_dup = PublishPacket.build('/test', b'data', 1, True, QOS_2, False) yield from publish_dup.to_stream(writer) yield from PubrecPacket.from_stream(reader) pubrel = PubrelPacket.build(1) yield from pubrel.to_stream(writer) yield from PubcompPacket.from_stream(reader) disconnect = DisconnectPacket() yield from disconnect.to_stream(writer) yield from asyncio.sleep(0.1) yield from broker.shutdown() future.set_result(True) except Exception as ae: future.set_exception(ae)
def test_coro(): try: broker = Broker(broker_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() client = MQTTClient() yield from client.connect('mqtt://127.0.0.1/') self.assertIsNotNone(client.session) ret = yield from client.subscribe([ ('$SYS/broker/uptime', QOS_0), ]) self.assertEqual(ret[0], QOS_0) yield from client.unsubscribe(['$SYS/broker/uptime']) yield from client.disconnect() yield from broker.shutdown() 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'', QOS_0, retain=True) yield from pub_client.disconnect() yield from asyncio.sleep(0.1) self.assertNotIn('/topic', broker._retained_messages) 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()) client = MQTTClient(client_id="", config={'auto_reconnect': False}) return_code = None try: yield from client.connect('mqtt://127.0.0.1/', cleansession=False) except ConnectException as ce: return_code = ce.return_code self.assertEqual(return_code, 0x02) self.assertNotIn(client.session.client_id, broker._sessions) yield from client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() 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( [('+', QOS_0), ('+/tennis/#', QOS_0), ('sport+', QOS_0), ('sport/+/player1', QOS_0)]) self.assertEqual(ret, [QOS_0, QOS_0, 0x80, QOS_0]) yield from asyncio.sleep(0.1) 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()) self.assertDictEqual(broker._sessions, {}) self.assertIn('default', broker._servers) MockPluginManager.assert_has_calls( [call().fire_event(EVENT_BROKER_PRE_START), call().fire_event(EVENT_BROKER_POST_START)], any_order=True) MockPluginManager.reset_mock() yield from broker.shutdown() MockPluginManager.assert_has_calls( [call().fire_event(EVENT_BROKER_PRE_SHUTDOWN), call().fire_event(EVENT_BROKER_POST_SHUTDOWN)], any_order=True) self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
class brokerServer(): def __init__(self): self.broker = None self.config = { 'listeners': { 'default': { 'max-connections': 50000, 'bind': '0.0.0.0:1883', 'type': 'tcp', }, }, 'plugins': ['auth_anonymous'], 'auth': { 'allow-anonymous': True, }, 'topic-check': { 'enabled': True, 'plugins': ['topic_taboo'], }, } async def broker_coroutine(self, config, loop): self.broker = Broker(config, loop) await self.broker.start() def start(self): loop = asyncio.new_event_loop() thread = Thread(target=lambda: self.run(loop)) thread.start() def run(self, loop): try: future = asyncio.gather(self.broker_coroutine(self.config, loop), loop=loop, return_exceptions=True) loop.run_until_complete(future) loop.run_forever() except (Exception, KeyboardInterrupt): loop.close() finally: loop.run_until_complete(self.broker.shutdown()) loop.close()
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://localhost/') self.assertEqual(ret, 0) yield from pub_client.publish('/+', b'data', QOS_0) yield from asyncio.sleep(0.1) yield from pub_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(broker_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() client = MQTTClient() yield from client.connect('mqtt://localhost/') self.assertIsNotNone(client.session) ret = yield from client.subscribe([ ('test_topic', QOS_0), ]) self.assertEqual(ret[0], QOS_0) with self.assertRaises(asyncio.TimeoutError): yield from client.deliver_message(timeout=2) yield from client.unsubscribe(['$SYS/broker/uptime']) yield from client.disconnect() yield from broker.shutdown() 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) 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()) client = MQTTClient(client_id="", config={'auto_reconnect': False}) return_code = None try: yield from client.connect('mqtt://localhost/', cleansession=False) except ConnectException as ce: return_code = ce.return_code self.assertEqual(return_code, 0x02) self.assertNotIn(client.session.client_id, broker._sessions) yield from client.disconnect() yield from asyncio.sleep(0.1) yield from broker.shutdown() 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()) conn_reader, conn_writer = \ yield from asyncio.open_connection('localhost', 1883, loop=self.loop) reader = StreamReaderAdapter(conn_reader) writer = StreamWriterAdapter(conn_writer) vh = ConnectVariableHeader() payload = ConnectPayload() vh.keep_alive = 10 vh.clean_session_flag = False vh.will_retain_flag = False vh.will_flag = True vh.will_qos = QOS_0 payload.client_id = 'test_id' payload.will_message = b'test' payload.will_topic = '/topic' connect = ConnectPacket(vh=vh, payload=payload) yield from connect.to_stream(writer) yield from ConnackPacket.from_stream(reader) yield from asyncio.sleep(0.1) disconnect = DisconnectPacket() yield from disconnect.to_stream(writer) yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) self.assertDictEqual(broker._sessions, {}) 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()) conn_reader, conn_writer = \ yield from asyncio.open_connection('127.0.0.1', 1883, loop=self.loop) reader = StreamReaderAdapter(conn_reader) writer = StreamWriterAdapter(conn_writer) vh = ConnectVariableHeader() payload = ConnectPayload() vh.keep_alive = 10 vh.clean_session_flag = False vh.will_retain_flag = False vh.will_flag = True vh.will_qos = QOS_0 payload.client_id = 'test_id' payload.will_message = b'test' payload.will_topic = '/topic' connect = ConnectPacket(vh=vh, payload=payload) yield from connect.to_stream(writer) yield from ConnackPacket.from_stream(reader) yield from asyncio.sleep(0.1) disconnect = DisconnectPacket() yield from disconnect.to_stream(writer) yield from asyncio.sleep(0.1) yield from broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) self.assertDictEqual(broker._sessions, {}) 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://localhost') ret = yield from sub_client.subscribe([('+', QOS_0), ('+/tennis/#', QOS_0), ('sport+', QOS_0), ('sport/+/player1', QOS_0)]) self.assertEqual(ret, [QOS_0, QOS_0, 0x80, QOS_0]) yield from asyncio.sleep(0.1) 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)
class MQTTServer(object): def __init__(self): self._port = 0 self._broker = None self._loop = asyncio.get_event_loop() if MQTT_SERVER_SUPPORTED else None @property def supported(self): return MQTT_SERVER_SUPPORTED @property def port(self): return self._port @port.setter def port(self, value): self._port = value def start(self): config = default_config config['listeners']['default']['bind'] = '0.0.0.0:' + str(self._port) self._broker = Broker(default_config) tt = Thread(target=self.run) tt.daemon = True tt.start() def run(self): try: self._loop.run_until_complete(self._broker.start()) self._loop.run_forever() self._loop.run_until_complete(self._broker.shutdown()) # self._loop.close() except: logging.exception("MQTT server exception") def stop(self): self._loop.call_soon_threadsafe(self._loop.stop)
def test_coro(): try: broker = Broker(test_config, plugin_namespace="hbmqtt.test.plugins") yield from broker.start() self.assertTrue(broker.transitions.is_started()) self.assertDictEqual(broker._sessions, {}) self.assertIn('default', broker._servers) MockPluginManager.assert_has_calls([ call().fire_event(EVENT_BROKER_PRE_START), call().fire_event(EVENT_BROKER_POST_START) ], any_order=True) MockPluginManager.reset_mock() yield from broker.shutdown() MockPluginManager.assert_has_calls([ call().fire_event(EVENT_BROKER_PRE_SHUTDOWN), call().fire_event(EVENT_BROKER_POST_SHUTDOWN) ], any_order=True) self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
class TestFakeMethods(): def __init__(self, bluetoothAudioBridge): self.TestResult = 0 self.broker = None self.bluetoothAudioBridge = bluetoothAudioBridge self.bluetoothAudioBridge.DbusBluezBusName = "BluetoothAudioBridge.FakeDbusObject" self.bluetoothAudioBridge.DbusBluezObjectPath = "/BluetoothAudioBridge/FakeDbusObject/hci0" self.bluetoothAudioBridge.MqttServer = mqttServer self.bluetoothAudioBridge.MqttUsername = mqttUsername self.bluetoothAudioBridge.MqttPassword = mqttPassword self.bluetoothAudioBridge.DbusBluezOnSystemBus = False @asyncio.coroutine def startFakeBroker(self): if startTheFakeBroker: print("Start fake broker") defaultMqtt = {} defaultMqtt["listeners"] = {} defaultMqtt["listeners"]["default"] = { "max-connections": 5, "type": "tcp" } defaultMqtt["listeners"]["my-tcp-1"] = {"bind": mqttServer} defaultMqtt["timeout-disconnect-delay"] = 2 defaultMqtt["auth"] = {} defaultMqtt["auth"]["plugins"] = ["auth.anonymous"] defaultMqtt["auth"]["allow-anonymous"] = True defaultMqtt["auth"]["password-file"] = None self.broker = Broker(defaultMqtt) try: yield from self.broker.start() except Exception: #workaround pass @asyncio.coroutine def stopFakeBroker(self): if startTheFakeBroker: print("shutdown fake broker") yield from self.broker.shutdown() def callerWithOneParameterWasCalled(self): def methodCall(parameter): print("parameter " + parameter) self.TestResult = self.TestResult + 1 return methodCall def callerWithOneParameterWasCalledAsync(self): async def methodCall(parameter): print("parameter " + parameter) self.TestResult = self.TestResult + 1 return methodCall async def sendMqttConnectMessage(self): mqttpublish.single("/BluetoothAudioBridge/commands", payload="Connect: ", hostname=mqttServer, port=1883, auth={ 'username': mqttUsername, 'password': mqttPassword }) print("connect message sent") async def sendMqttPairAndTrustMessage(self): mqttpublish.single("/BluetoothAudioBridge/commands", payload="Pair and trust: ", hostname=mqttServer, port=1883, auth={ 'username': mqttUsername, 'password': mqttPassword }) print("pair and trust message sent") async def sendMqttScanMessage(self): mqttpublish.single("/BluetoothAudioBridge/commands", payload="Scan:", hostname=mqttServer, port=1883, auth={ 'username': mqttUsername, 'password': mqttPassword }) print("scan message sent") async def cancelIn2Seconds(self): await asyncio.sleep(2) self.bluetoothAudioBridge.CancellationToken.set_result(True) async def setResultInXSecondsCancelable(self, time): (finished, result) = await self.bluetoothAudioBridge.awaitOrStop( asyncio.sleep(time)) if finished: print("set Result to true") self.TestResult = 1
class MQTTBroker(devices.Device): deviceTypeName = 'MQTTBroker' readme = os.path.join(os.path.dirname(__file__), "README.md") defaultSubclassCode = defaultSubclassCode @asyncio.coroutine def broker_coro(self): from hbmqtt.broker import Broker conf = { 'listeners': { 'default': { 'bind': self.bind, 'type': 'tcp' }, 'auth': { 'plugins': ['auth.anonymous'], 'allow-anonymous': True } } } if self.wsAddr: ws = {'type': 'ws', 'bind': self.wsAddr} conf['listeners']['ws-1'] = ws self.broker = Broker(conf) yield from self.broker.start() def close(self): try: self.broker.shutdown() except: self.handleException() try: self.loop.stop() except: self.handleException() try: self.loop.close() except: self.handleException() devices.Device.close(self) def __del__(self): self.close() def __init__(self, name, data): devices.Device.__init__(self, name, data) self.closed = False try: self.loop = asyncio.new_event_loop() if not data['device.bindTo'].strip(): raise RuntimeError("No address selected") self.bind = data['device.bindTo'].strip() self.wsAddr = data['device.wsAddr'].strip() self.loop.run_until_complete(self.broker_coro()) self.thread = threading.thread(t=self.get_event_loop().run_forever) self.thread.start() except Exception: self.handleException() def getManagementForm(self): return templateGetter.get_template("manageform.html").render( data=self.data, obj=self)