def _create_connection(self, auth_type=AuthType.CERT_AND_KEY, use_static_singletons=False):
config = Config(auth_type)
if auth_type == AuthType.CERT_AND_KEY:
tls_opts = TlsContextOptions.create_client_with_mtls_from_path(config.cert_path, config.key_path)
tls = ClientTlsContext(tls_opts)
elif auth_type == AuthType.PKCS11:
try:
pkcs11_lib = Pkcs11Lib(
file=config.pkcs11_lib_path,
behavior=Pkcs11Lib.InitializeFinalizeBehavior.STRICT)
tls_opts = TlsContextOptions.create_client_with_mtls_pkcs11(
pkcs11_lib=pkcs11_lib,
user_pin=config.pkcs11_pin,
token_label=config.pkcs11_token_label,
private_key_label=config.pkcs11_key_label,
cert_file_path=config.cert_path)
tls = ClientTlsContext(tls_opts)
except Exception as e:
if 'AWS_ERROR_UNIMPLEMENTED' in str(e):
raise unittest.SkipTest(f'TLS with PKCS#11 not supported on this platform ({sys.platform})')
else:
# re-raise exception
raise
if use_static_singletons:
client = Client(tls_ctx=tls)
else:
elg = EventLoopGroup()
resolver = DefaultHostResolver(elg)
bootstrap = ClientBootstrap(elg, resolver)
client = Client(bootstrap, tls)
connection = Connection(
client=client,
client_id=create_client_id(),
host_name=config.endpoint,
port=8883)
return connection
def test_on_message_old_fn_signature(self):
# ensure that message-received callbacks with the old function signature still work
config = Config.get()
elg = EventLoopGroup()
resolver = DefaultHostResolver(elg)
bootstrap = ClientBootstrap(elg, resolver)
tls_opts = TlsContextOptions.create_client_with_mtls(
config.cert, config.key)
tls = ClientTlsContext(tls_opts)
client = Client(bootstrap, tls)
connection = Connection(client=client,
client_id=create_client_id(),
host_name=config.endpoint,
port=8883)
any_received = Future()
sub_received = Future()
# Note: Testing degenerate callback signature that failed to take
# forward-compatibility **kwargs.
def on_any_message(topic, payload):
any_received.set_result({'topic': topic, 'payload': payload})
def on_sub_message(topic, payload):
sub_received.set_result({'topic': topic, 'payload': payload})
# on_message for connection has to be set before connect, or possible race will happen
connection.on_message(on_any_message)
connection.connect().result(TIMEOUT)
# subscribe without callback
subscribed, packet_id = connection.subscribe(self.TEST_TOPIC,
QoS.AT_LEAST_ONCE,
on_sub_message)
subscribed.result(TIMEOUT)
# publish
published, packet_id = connection.publish(self.TEST_TOPIC,
self.TEST_MSG,
QoS.AT_LEAST_ONCE)
puback = published.result(TIMEOUT)
# receive message
rcv = any_received.result(TIMEOUT)
self.assertEqual(self.TEST_TOPIC, rcv['topic'])
self.assertEqual(self.TEST_MSG, rcv['payload'])
rcv = sub_received.result(TIMEOUT)
self.assertEqual(self.TEST_TOPIC, rcv['topic'])
self.assertEqual(self.TEST_MSG, rcv['payload'])
# disconnect
connection.disconnect().result(TIMEOUT)
def _test_connection(self):
config = Config.get()
elg = EventLoopGroup()
resolver = DefaultHostResolver(elg)
bootstrap = ClientBootstrap(elg, resolver)
tls_opts = TlsContextOptions.create_client_with_mtls(
config.cert, config.key)
tls = ClientTlsContext(tls_opts)
client = Client(bootstrap, tls)
connection = Connection(client=client,
client_id=create_client_id(),
host_name=config.endpoint,
port=8883)
connection.connect().result(TIMEOUT)
return connection
def test_on_message(self):
config = Config.get()
elg = EventLoopGroup()
resolver = DefaultHostResolver(elg)
bootstrap = ClientBootstrap(elg, resolver)
tls_opts = TlsContextOptions.create_client_with_mtls(
config.cert, config.key)
tls = ClientTlsContext(tls_opts)
client = Client(bootstrap, tls)
connection = Connection(client=client,
client_id=create_client_id(),
host_name=config.endpoint,
port=8883)
received = Future()
def on_message(**kwargs):
received.set_result(kwargs)
# on_message for connection has to be set before connect, or possible race will happen
connection.on_message(on_message)
connection.connect().result(TIMEOUT)
# subscribe without callback
subscribed, packet_id = connection.subscribe(self.TEST_TOPIC,
QoS.AT_LEAST_ONCE)
subscribed.result(TIMEOUT)
# publish
published, packet_id = connection.publish(self.TEST_TOPIC,
self.TEST_MSG,
QoS.AT_LEAST_ONCE)
puback = published.result(TIMEOUT)
# receive message
rcv = received.result(TIMEOUT)
self.assertEqual(self.TEST_TOPIC, rcv['topic'])
self.assertEqual(self.TEST_MSG, rcv['payload'])
self.assertFalse(rcv['dup'])
self.assertEqual(QoS.AT_LEAST_ONCE, rcv['qos'])
self.assertFalse(rcv['retain'])
# disconnect
connection.disconnect().result(TIMEOUT)
def _establish_mqtt_connection(self, proxy_options):
event_loop_group = EventLoopGroup()
host_resolver = DefaultHostResolver(event_loop_group)
bootstrap = ClientBootstrap(event_loop_group, host_resolver)
tls_opts = TlsContextOptions.create_client_with_mtls_from_path(
ProxyTestConfiguration.HTTP_PROXY_TLS_CERT_PATH,
ProxyTestConfiguration.HTTP_PROXY_TLS_KEY_PATH)
tls_opts.override_default_trust_store_from_path(
ca_filepath=ProxyTestConfiguration.HTTP_PROXY_TLS_ROOT_CA_PATH)
tls = ClientTlsContext(tls_opts)
client = Client(bootstrap, tls)
connection = Connection(
client=client,
client_id=create_client_id(),
host_name=ProxyTestConfiguration.HTTP_PROXY_MQTT_ENDPOINT,
port=8883,
proxy_options=proxy_options)
connection.connect().result(TIMEOUT)
return connection
def test_lifetime(self):
elg = EventLoopGroup()
resolver = DefaultHostResolver(elg)
bootstrap = ClientBootstrap(elg, resolver)
client = Client(bootstrap)