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 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://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 async_start(hass, password, server_config): """Initialize MQTT Server. This method is a coroutine. """ from hbmqtt.broker import Broker, BrokerException passwd = tempfile.NamedTemporaryFile() gen_server_config, client_config = generate_config(hass, passwd, password) try: if server_config is None: server_config = gen_server_config broker = Broker(server_config, hass.loop) yield from broker.start() except BrokerException: _LOGGER.exception("Error initializing MQTT server") return False, None finally: passwd.close() @asyncio.coroutine def async_shutdown_mqtt_server(event): """Shut down the MQTT server.""" yield from broker.shutdown() hass.bus.async_listen_once( EVENT_HOMEASSISTANT_STOP, async_shutdown_mqtt_server) return True, client_config
def async_start(hass, server_config): """Initialize MQTT Server. This method is a coroutine. """ from hbmqtt.broker import Broker, BrokerException try: passwd = tempfile.NamedTemporaryFile() if server_config is None: server_config, client_config = generate_config(hass, passwd) else: client_config = None broker = Broker(server_config, hass.loop) yield from broker.start() except BrokerException: logging.getLogger(__name__).exception('Error initializing MQTT server') return False, None finally: passwd.close() @asyncio.coroutine def async_shutdown_mqtt_server(event): """Shut down the MQTT server.""" yield from broker.shutdown() hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_shutdown_mqtt_server) return True, client_config
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 broker_coro(): global broker brokerConfig = { "listeners": { "default": { "bind": "0.0.0.0:" + str(c.config["mqtt"]["tcp_port"]), "type": "tcp", "ssl": c.config["ssl"]["enabled"], "cafile": c.config["ssl"]["chain_file"], "certfile": c.config["ssl"]["cert_file"], "keyfile": c.config["ssl"]["key_file"] }, "ws": { "bind": "0.0.0.0:" + str(c.config["mqtt"]["ws_port"]), "type": "ws", "ssl": c.config["ssl"]["enabled"], "cafile": c.config["ssl"]["chain_file"], "certfile": c.config["ssl"]["cert_file"], "keyfile": c.config["ssl"]["key_file"] } }, "timeout-disconnect-delay": 2, "topic-check": { "enabled": True, "plugins": ["mqtt_plugin_alfons_topic"] }, "auth": { "plugins": ["mqtt_plugin_alfons_auth"], "authorizer": a.authorize } } broker = Broker(brokerConfig, None) yield from broker.start()
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) 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 start(hass, server_config): """Initialize MQTT Server.""" from hbmqtt.broker import Broker, BrokerException try: passwd = tempfile.NamedTemporaryFile() if server_config is None: server_config, client_config = generate_config(hass, passwd) else: client_config = None broker = Broker(server_config, hass.loop) run_coroutine_threadsafe(broker.start(), hass.loop).result() except BrokerException: logging.getLogger(__name__).exception('Error initializing MQTT server') return False, None finally: passwd.close() @callback def shutdown_mqtt_server(event): """Shut down the MQTT server.""" hass.async_add_job(broker.shutdown()) hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, shutdown_mqtt_server) return True, client_config
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(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()) 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()) 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(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 async_start(hass, password, server_config): """Initialize MQTT Server. This method is a coroutine. """ # pylint: disable=import-outside-toplevel from hbmqtt.broker import Broker, BrokerException passwd = tempfile.NamedTemporaryFile() gen_server_config, client_config = generate_config(hass, passwd, password) try: if server_config is None: server_config = gen_server_config broker = Broker(server_config, hass.loop) yield from broker.start() except BrokerException: _LOGGER.exception("Error initializing MQTT server") return False, None finally: passwd.close() @asyncio.coroutine def async_shutdown_mqtt_server(event): """Shut down the MQTT server.""" yield from broker.shutdown() hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_shutdown_mqtt_server) return True, client_config
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://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 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()
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()
def broker_coro(): config = None with open('./config.yml', 'r') as stream: config = yaml.safe_load(stream) print(config) broker = Broker(config) yield from 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()
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 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() 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)
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 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 broker_coro(): stream = """ listeners: default: max-connections: 443 type: tcp my-ws-1: bind: 0.0.0.0:8080 type: ws timeout-disconnect-delay: 2 """ config = yaml.load(stream) print(config) broker = Broker(config=config) yield from broker.start()
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await 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() await 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)
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await broker.start() self.assertTrue(broker.transitions.is_started()) sub_client = MQTTClient() await sub_client.connect(f"mqtt://127.0.0.1:{self._test_port}/") ret = await sub_client.subscribe([("+/monitor/Clients", QOS_0)]) self.assertEqual(ret, [QOS_0]) await self._client_publish("/test/monitor/Clients", b"data", QOS_0) message = await sub_client.deliver_message() self.assertIsNotNone(message) await self._client_publish("$SYS/monitor/Clients", b"data", QOS_0) await asyncio.sleep(0.1) message = None try: message = await sub_client.deliver_message(timeout=2) except Exception: # noqa: E722 pass self.assertIsNone(message) await sub_client.disconnect() await asyncio.sleep(0.1) await broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await broker.start() self.assertTrue(broker.transitions.is_started()) sub_client = MQTTClient() await sub_client.connect(f"mqtt://127.0.0.1:{self._test_port}/") ret = await 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]) await asyncio.sleep(0.1) await sub_client.disconnect() await asyncio.sleep(0.1) await broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await broker.start() self.assertTrue(broker.transitions.is_started()) sub_client = MQTTClient() await sub_client.connect(f"mqtt://127.0.0.1:{self._test_port}/") ret = await sub_client.subscribe( [("/qos0", QOS_0), ("/qos1", QOS_1), ("/qos2", QOS_2)] ) self.assertEqual(ret, [QOS_0, QOS_1, QOS_2]) await self._client_publish("/qos0", b"data", QOS_0) await self._client_publish("/qos1", b"data", QOS_1) await self._client_publish("/qos2", b"data", QOS_2) await asyncio.sleep(0.1) for qos in [QOS_0, QOS_1, QOS_2]: message = await 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) await sub_client.disconnect() await asyncio.sleep(0.1) await broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await broker.start() self.assertTrue(broker.transitions.is_started()) pub_client = MQTTClient() ret = await pub_client.connect(f"mqtt://127.0.0.1:{self._test_port}/") self.assertEqual(ret, 0) await pub_client.publish("/topic", b"data", QOS_0, retain=True) await pub_client.disconnect() await 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) await broker.shutdown() self.assertTrue(broker.transitions.is_stopped()) future.set_result(True) except Exception as ae: future.set_exception(ae)
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await broker.start() self.assertTrue(broker.transitions.is_started()) pub_client = MQTTClient() ret = await pub_client.connect(f"mqtt://127.0.0.1:{self._test_port}/") self.assertEqual(ret, 0) ret_message = await pub_client.publish( "/topic", bytearray(b"\x99" * 256 * 1024), QOS_2 ) await pub_client.disconnect() self.assertEqual(broker._retained_messages, {}) await asyncio.sleep(0.1) await 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)
async def test_coro(): try: broker = Broker( self._test_config, plugin_namespace="hbmqtt.test.plugins" ) await broker.start() client = MQTTClient() await client.connect(f"mqtt://127.0.0.1:{self._tcp_port}/") self.assertIsNotNone(client.session) ret = await client.subscribe( [ ("test_topic", QOS_0), ] ) self.assertEqual(ret[0], QOS_0) client_pub = MQTTClient() await client_pub.connect(f"mqtt://127.0.0.1:{self._tcp_port}/") await client_pub.publish("test_topic", data, QOS_0) await client_pub.disconnect() message = await client.deliver_message() self.assertIsNotNone(message) self.assertIsNotNone(message.publish_packet) self.assertEqual(message.data, data) await client.unsubscribe(["$SYS/broker/uptime"]) await client.disconnect() await broker.shutdown() future.set_result(True) except Exception as ae: future.set_exception(ae)
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(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()) 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(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)
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()) 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()) 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 __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 broker_coro(loop, config): """Start broker coroutine.""" from hbmqtt.broker import Broker broker = Broker(config, loop) yield from broker.start() return broker