async def test_coro():
async with distkv_server(1):
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient(
config=broker_config["broker"]) as client:
self.assertIsNotNone(client.session)
ret = await client.subscribe([("test/vis/foo", QOS_0)])
self.assertEqual(ret[0], QOS_0)
async with open_mqttclient(
config=broker_config["broker"]) as client_pub:
await client_pub.publish("test/vis/foo",
data,
QOS_0,
retain=False)
async with anyio.fail_after(0.5):
message = await client.deliver_message()
self.assertIsNotNone(message)
self.assertIsNotNone(message.publish_packet)
self.assertEqual(message.data, data)
pass # exit client
pass # exit broker
pass # exit server
pass # exit test
async def test_coro():
async with distkv_server(0) as s:
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins") as broker:
async with open_mqttclient() as client:
await client.connect('mqtt://127.0.0.1/')
self.assertIsNotNone(client.session)
async with open_mqttclient() as client_pub:
await client_pub.connect('mqtt://127.0.0.1/')
await client_pub.publish('test_topic',
data,
QOS_0,
retain=True)
await anyio.sleep(1)
async with open_mqttclient() as client:
await client.connect('mqtt://127.0.0.1/')
self.assertIsNotNone(client.session)
ret = await client.subscribe([
('test_topic', QOS_0),
])
self.assertEqual(ret[0], QOS_0)
async with anyio.fail_after(0.5):
message = await client.deliver_message()
self.assertIsNotNone(message)
self.assertIsNotNone(message.publish_packet)
self.assertEqual(message.data, data)
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins") as broker:
async with open_mqttclient() as client:
await client.connect('mqtt://127.0.0.1/')
self.assertIsNotNone(client.session)
ret = await client.subscribe([
('test_topic', QOS_0),
])
self.assertEqual(ret[0], QOS_0)
async with anyio.fail_after(0.5):
message = await client.deliver_message()
self.assertIsNotNone(message)
self.assertIsNotNone(message.publish_packet)
self.assertEqual(message.data, data)
seen = 0
for h, p, *_ in s.ports:
if h[0] != ":":
break
async with open_client(host=h, port=p) as cl:
async for m in cl.get_tree(min_depth=1):
del m['tock']
del m['seq']
assert m == {
'path': ('test', 'retain', 'test_topic'),
'value': b'data 1234'
}
seen += 1
assert seen == 1
async def test_coro():
async with create_broker(
test_config, plugin_namespace="distmqtt.test.plugins"
) as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as client:
ret = await client.connect(URL)
self.assertEqual(ret, 0)
self.assertEqual(len(broker._sessions), 1)
self.assertIn(client.session.client_id, broker._sessions)
await anyio.sleep(0.1) # let the broker task process the packet
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,
)
async def test_coro():
async with create_broker(
test_config, plugin_namespace="distmqtt.test.plugins"
) as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as sub_client:
await sub_client.connect(URL, cleansession=False)
ret = await sub_client.subscribe(
[("/qos0", QOS_0), ("/qos1", QOS_1), ("/qos2", QOS_2)]
)
self.assertEqual(ret, [QOS_0, QOS_1, QOS_2])
await sub_client.disconnect()
await self._client_publish("/qos0", b"data", QOS_0, retain=True)
await self._client_publish("/qos1", b"data", QOS_1, retain=True)
await self._client_publish("/qos2", b"data", QOS_2, retain=True)
await sub_client.reconnect()
for qos in [QOS_0, QOS_1, QOS_2]:
log.debug("TEST QOS: %d", qos)
message = await sub_client.deliver_message()
log.debug("Message: %r", message.publish_packet)
self.assertIsNotNone(message)
self.assertEqual(message.topic, "/qos%s" % qos)
self.assertEqual(message.data, b"data")
self.assertEqual(message.qos, qos)
self.assertTrue(broker.transitions.is_stopped())
async def test_coro():
async with open_mqttclient(
config={"check_hostname": False}) as client:
ca = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"mosquitto.org.crt")
await client.connect("mqtts://test.mosquitto.org/", cafile=ca)
self.assertIsNotNone(client.session)
async def test_coro():
async with create_broker(
test_config, plugin_namespace="distmqtt.test.plugins"
) as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as pub_client:
ret = await pub_client.connect(URL)
self.assertEqual(ret, 0)
ret_message = await pub_client.publish(
"/topic", bytearray(b"\x99" * 256 * 1024), QOS_2
)
self.assertEqual(broker._retained_messages, {})
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,
)
async def main(*args, **kwargs):
arguments = docopt(__doc__, version=get_version())
#print(arguments)
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_client.yaml'))
logger.debug("Using default configuration")
client_id = arguments.get("-i", None)
if not client_id:
client_id = _gen_client_id()
if arguments['-k']:
config['keep_alive'] = int(arguments['-k'])
if arguments['--will-topic'] and arguments['--will-message'] and arguments['--will-qos']:
config['will'] = dict()
config['will']['topic'] = arguments['--will-topic']
config['will']['message'] = arguments['--will-message'].encode('utf-8')
config['will']['qos'] = int(arguments['--will-qos'])
config['will']['retain'] = arguments['--will-retain']
async with open_mqttclient(client_id=client_id, config=config) as C:
await do_pub(C, arguments)
async def test_coro2():
async with open_mqttclient(config=config) as C:
await C.connect('mqtt://test.mosquitto.org:1883/')
await C.publish('a/b', b'TEST MESSAGE WITH QOS_0', qos=0x00)
await C.publish('a/b', b'TEST MESSAGE WITH QOS_1', qos=0x01)
await C.publish('a/b', b'TEST MESSAGE WITH QOS_2', qos=0x02)
logger.info("messages published")
async def test_coro():
async with create_broker(
test_config,
plugin_namespace="distmqtt.test.plugins") as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as sub_client:
await sub_client.connect('mqtt://127.0.0.1')
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)
message = None
with self.assertRaises(TimeoutError):
async with anyio.fail_after(2):
message = await sub_client.deliver_message()
self.assertIsNone(message)
self.assertTrue(broker.transitions.is_stopped())
async def test_coro2():
async with open_mqttclient(config=config) as C:
await C.connect("mqtt://test.mosquitto.org:1883/")
await C.publish("a/b", b"TEST MESSAGE WITH QOS_0", qos=0x00)
await C.publish("a/b", b"TEST MESSAGE WITH QOS_1", qos=0x01)
await C.publish("a/b", b"TEST MESSAGE WITH QOS_2", qos=0x02)
logger.info("messages published")
async def test_coro():
async with create_broker(
test_config,
plugin_namespace="distmqtt.test.plugins") as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as client:
ret = await client.connect('mqtt://127.0.0.1/')
self.assertEqual(ret, 0)
await 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)
await client.unsubscribe(['/topic'])
self.assertEqual(broker._subscriptions['/topic'], [])
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),
call().fire_event(EVENT_BROKER_CLIENT_UNSUBSCRIBED,
client_id=client.session.client_id,
topic='/topic')
],
any_order=True)
async def test_coro():
async with create_broker(broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient() as client:
await client.connect(URI)
self.assertIsNotNone(client.session)
ret = await client.subscribe([("test_topic", QOS_0)])
self.assertEqual(ret[0], QOS_0)
async with open_mqttclient() as client_pub:
await client_pub.connect(URI)
await client_pub.publish("test_topic", data, QOS_0)
message = await client.deliver_message()
self.assertIsNotNone(message)
self.assertIsNotNone(message.publish_packet)
self.assertEqual(message.data, data)
await client.unsubscribe(["$SYS/broker/uptime"])
async def test_coro():
async with create_broker(broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient() as client:
await client.connect(URI)
self.assertIsNotNone(client.session)
await client.ping()
async def test_coro():
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins") as broker:
async with open_mqttclient() as client:
await client.connect('ws://127.0.0.1:8080/')
self.assertIsNotNone(client.session)
async def test_coro():
async with open_mqttclient(config=config) as C:
await C.connect("mqtts://test.mosquitto.org/", cafile="mosquitto.org.crt")
async with anyio.create_task_group() as tg:
await tg.spawn(C.publish("a/b", b"TEST MESSAGE WITH QOS_0"))
await tg.spawn(C.publish("a/b", b"TEST MESSAGE WITH QOS_1", qos=QOS_1))
await tg.spawn(C.publish("a/b", b"TEST MESSAGE WITH QOS_2", qos=QOS_2))
logger.info("messages published")
async def test_coro():
async with create_broker(broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient() as client:
ca = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"mosquitto.org.crt")
await client.connect("ws://127.0.0.1:8081/", cafile=ca)
self.assertIsNotNone(client.session)
async def test_coro():
try:
config = {"auto_reconnect": False}
async with open_mqttclient(config=config) as client:
await client.connect(URI)
except ConnectException:
pass
else:
raise RuntimeError("should not be able to connect")
async def handle_device_alarm(self, device):
"""
Listens for a device's alarm event and publishes a message on arrival.
:param device: The device to listen to
"""
await device.alarm.wait()
async with open_mqttclient(uri=self.broker_host) as client:
logging.info(f"Publish on '{self.topic_name(device)}':\n" f"alarm")
await client.publish(f'{self.topic_name(device)}', b'alarm', QOS_1)
async def test_coro():
try:
config = {'auto_reconnect': False}
async with open_mqttclient(config=config) as client:
await client.connect('mqtt://127.0.0.1/')
except ConnectException as e:
pass
else:
raise RuntimeError("should not be able to connect")
async def test_coro():
async with create_broker(broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient() as client:
await client.connect("ws://*****:*****@127.0.0.1:8080/")
self.assertIsNotNone(client.session)
await client.reconnect()
self.assertIsNotNone(client.session.username)
self.assertIsNotNone(client.session.password)
async def test_coro():
async with create_broker(broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient() as client:
await client.connect(URI)
self.assertIsNotNone(client.session)
ret = await client.subscribe([("$SYS/broker/uptime", QOS_0)
])
self.assertEqual(ret[0], QOS_0)
await client.unsubscribe(["$SYS/broker/uptime"])
async def handle_device_update(self, device):
"""
Listens to a device's update events and publish a message on arrival
:param device: The device to listen for updates for
"""
await device.updated.wait()
async with open_mqttclient(uri=self.broker_host) as client:
logging.info(f"Publish on '{self.topic_name(device)}':\n"
f"{device.json.encode('utf-8')}")
await client.publish(f'{self.topic_name(device)}',
device.json.encode('utf-8'), QOS_1)
async def test_coro():
async with create_broker(broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient() as client:
await client.connect(URI)
self.assertIsNotNone(client.session)
ret = await client.subscribe([("test_topic", QOS_0)])
self.assertEqual(ret[0], QOS_0)
with self.assertRaises(TimeoutError):
async with anyio.fail_after(2):
await client.deliver_message()
await client.unsubscribe(["$SYS/broker/uptime"])
async def test_coro():
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins") as broker:
async with open_mqttclient() as client:
await client.connect('mqtt://127.0.0.1/')
self.assertIsNotNone(client.session)
ret = await client.subscribe([
('$SYS/broker/uptime', QOS_0),
])
self.assertEqual(ret[0], QOS_0)
await client.unsubscribe(['$SYS/broker/uptime'])
async def test_coro():
async with distkv_server(0):
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins"):
async with open_mqttclient(
config=broker_config["broker"]) as client:
self.assertIsNotNone(client.session)
ret = await client.subscribe([("test_topic", QOS_0)])
self.assertEqual(ret[0], QOS_0)
with self.assertRaises(TimeoutError):
async with anyio.fail_after(2):
await client.deliver_message()
async def test_coro():
async with create_broker(
test_config,
plugin_namespace="distmqtt.test.plugins") as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as pub_client:
ret = await pub_client.connect('mqtt://127.0.0.1/')
self.assertEqual(ret, 0)
await pub_client.publish('/+', b'data', QOS_0)
self.assertTrue(broker.transitions.is_stopped())
async def test_coro():
async with distkv_server(0):
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins") as broker:
async with open_mqttclient() as client:
await client.connect('mqtt://127.0.0.1/')
self.assertIsNotNone(client.session)
ret = await client.subscribe([
('test_topic', QOS_0),
])
self.assertEqual(ret[0], QOS_0)
async with open_mqttclient() as client_pub:
await client_pub.connect('mqtt://127.0.0.1/')
await client_pub.publish('test_topic',
data,
QOS_0,
retain=True)
async with anyio.fail_after(0.5):
message = await client.deliver_message()
self.assertIsNotNone(message)
self.assertIsNotNone(message.publish_packet)
self.assertEqual(message.data, data)
async def test_coro():
async with create_broker(
test_config, plugin_namespace="distmqtt.test.plugins"
) as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as pub_client:
ret = await pub_client.connect(URL)
self.assertEqual(ret, 0)
await pub_client.publish("/topic", b"", QOS_0, retain=True)
await anyio.sleep(0.1) # let the broker task process the packet
self.assertNotIn("/topic", broker._retained_messages)
self.assertTrue(broker.transitions.is_stopped())
async def test_coro():
async with distkv_server(0):
async with create_broker(
broker_config,
plugin_namespace="distmqtt.test.plugins") as broker:
async with open_mqttclient() as client:
await client.connect('mqtt://127.0.0.1/')
self.assertIsNotNone(client.session)
ret = await client.subscribe([
('test_topic', QOS_0),
])
self.assertEqual(ret[0], QOS_0)
with self.assertRaises(TimeoutError):
async with anyio.fail_after(2):
await client.deliver_message()
async def test_coro():
async with create_broker(
test_config,
plugin_namespace="distmqtt.test.plugins") as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient() as sub_client:
await sub_client.connect('mqtt://127.0.0.1')
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])
self.assertTrue(broker.transitions.is_stopped())
