async def test_coro():
async with distkv_server(0) as s:
async with create_broker(
broker_config,
plugin_namespace="hbmqtt.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="hbmqtt.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="hbmqtt.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_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(
broker_config,
plugin_namespace="hbmqtt.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={'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 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_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="hbmqtt.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)
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="hbmqtt.test.plugins") as broker:
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():
async with create_broker(test_config, plugin_namespace="hbmqtt.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 create_broker(test_config, plugin_namespace="hbmqtt.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())
async def test_coro():
async with create_broker(test_config, plugin_namespace="hbmqtt.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('/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 create_broker(
broker_config,
plugin_namespace="hbmqtt.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 create_broker(test_config, plugin_namespace="hbmqtt.test.plugins") as broker:
broker.plugins_manager._tg = broker._tg
self.assertTrue(broker.transitions.is_started())
async with open_mqttclient(client_id="", config={'auto_reconnect': False}) as client:
return_code = None
try:
await 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)
async def test_coro():
async with distkv_server(0):
async with create_broker(
broker_config,
plugin_namespace="hbmqtt.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 distkv_server(0):
async with create_broker(
broker_config,
plugin_namespace="hbmqtt.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 open_mqttclient(config=config) as C:
await C.connect('mqtt://test.mosquitto.org/')
async with anyio.create_task_group() as tg:
await tg.spawn(C.publish, 'a/b', b'TEST MESSAGE WITH QOS_0')
await tg.spawn(
partial(C.publish,
'a/b',
b'TEST MESSAGE WITH QOS_1',
qos=QOS_1))
await tg.spawn(
partial(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(test_config, plugin_namespace="hbmqtt.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)
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="hbmqtt.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)
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 uptime_coro():
async with open_mqttclient() as C:
await C.connect('mqtt://test.mosquitto.org/')
try:
await C.subscribe([
('$SYS/broker/uptime', QOS_1),
('$SYS/broker/load/#', QOS_2),
])
logger.info("Subscribed")
for i in range(1, 100):
message = await C.deliver_message()
packet = message.publish_packet
print("%d: %s => %s" % (i, packet.variable_header.topic_name,
str(packet.payload.data)))
await C.unsubscribe(['$SYS/broker/uptime', '$SYS/broker/load/#'])
logger.info("UnSubscribed")
except ClientException as ce:
logger.error("Client exception: %r", ce)
async def test_coro():
async with create_broker(test_config, plugin_namespace="hbmqtt.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([('/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)
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)
self.assertTrue(broker.transitions.is_stopped())
async def test_coro():
async with open_mqttclient(config=config) as sub_client:
await sub_client.connect('mqtt://127.0.0.1', cleansession=False)
ret = await sub_client.subscribe([('/qos0', QOS_0), ('/qos1', QOS_1),
('/qos2', QOS_2)])
await sub_client.disconnect()
await anyio.sleep(0.1)
await _client_publish('/qos0', b'data', QOS_0, retain=True)
await _client_publish('/qos1', b'data', QOS_1, retain=True)
await _client_publish('/qos2', b'data', QOS_2, retain=True)
import pdb
pdb.set_trace()
await sub_client.reconnect()
for qos in [QOS_0, QOS_1, QOS_2]:
logger.debug("TEST QOS: %d", qos)
message = await sub_client.deliver_message()
logger.debug("Message: " + repr(message.publish_packet))
await anyio.sleep(0.1)
async def test_coro():
try:
async with open_mqttclient() as C:
await C.connect('mqtt://0.0.0.0:1883')
await C.publish('data/classified', b'TOP SECRET', qos=0x01)
await C.publish('data/memes', b'REAL FUN', qos=0x01)
await C.publish('repositories/hbmqtt/master',
b'NEW STABLE RELEASE',
qos=0x01)
await C.publish('repositories/hbmqtt/devel',
b'THIS NEEDS TO BE CHECKED',
qos=0x01)
await C.publish('calendar/hbmqtt/releases',
b'NEW RELEASE',
qos=0x01)
logger.info("messages published")
except ConnectException as ce:
logger.error("Connection failed: %r", ce)
async def test_coro():
async with create_broker(test_config, plugin_namespace="hbmqtt.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 uptime_coro():
async with open_mqttclient() as C:
await C.connect('mqtt://*****:*****@0.0.0.0:1883')
# Subscribe to '$SYS/broker/uptime' with QOS=1
try:
await C.subscribe([
('data/memes', QOS_1), # Topic allowed
('data/classified', QOS_1), # Topic forbidden
('repositories/hbmqtt/master', QOS_1), # Topic allowed
('repositories/hbmqtt/devel', QOS_1), # Topic forbidden
('calendar/hbmqtt/releases', QOS_1), # Topic allowed
])
logger.info("Subscribed")
for i in range(1, 100):
message = await C.deliver_message()
packet = message.publish_packet
print("%d: %s => %s" % (i, packet.variable_header.topic_name, str(packet.payload.data)))
await C.unsubscribe(['$SYS/broker/uptime', '$SYS/broker/load/#'])
logger.info("UnSubscribed")
except ClientException as ce:
logger.error("Client exception: %r", ce)
async def test_coro():
async with create_broker(test_config, plugin_namespace="hbmqtt.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', 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: " + 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)
self.assertTrue(broker.transitions.is_stopped())
async def _client_publish(self, topic, data, qos, retain=False):
async with open_mqttclient() as pub_client:
ret = await pub_client.connect('mqtt://127.0.0.1/')
self.assertEqual(ret, 0)
ret = await pub_client.publish(topic, data, qos, retain)
return ret
async def test_coro():
async with open_mqttclient() as client:
await client.connect('mqtt://test.mosquitto.org/')
self.assertIsNotNone(client.session)
async def test_coro():
async with open_mqttclient() as C:
await C.connect('mqtt://test.mosquitto.org:1883/')
await anyio.sleep(18)
