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(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)
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 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(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())
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 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())
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)
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())
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
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)
