async def _get_device_provisioning_client_adapter(settings_object):
"""
get a device client adapter for the given settings object
"""
adapter = adapters.create_adapter(settings_object.adapter_address,
"device_provisioning")
return adapter
async def get_device_client(settings_object):
"""
get a device client for the given settings object
"""
client = adapters.create_adapter(settings_object.adapter_address,
"device_client")
client.device_id = settings_object.device_id
client.capabilities = settings_object.capabilities
client.settings = settings_object
client.settings.client = client
if settings_object.capabilities.v2_connect_group:
await client.create_from_connection_string(
settings_object.transport,
settings_object.connection_string,
get_ca_cert(settings_object),
)
else:
await client.connect(
settings_object.transport,
settings_object.connection_string,
get_ca_cert(settings_object),
)
return client
def collect_capabilities():
# BKTODO: add an under_test flag to settings and make _objects public so we can iterate
for horton_object in (
settings.test_module,
settings.friend_module,
settings.test_device,
settings.leaf_device,
):
if horton_object.device_id:
horton_object.wrapper_api = adapters.create_adapter(
horton_object.adapter_address, "wrapper")
try:
caps = horton_object.wrapper_api.get_capabilities_sync()
except HttpOperationError:
caps = None
horton_object.capabilities = HortonCapabilities()
if caps:
flags = caps["flags"]
for flag_name in flags:
setattr(horton_object.capabilities, flag_name,
flags[flag_name])
horton_object.skip_list = list(caps["skip_list"])
else:
horton_object.skip_list = hardcoded_skip_list[
horton_object.language]
for flag_name in dir(horton_object.capabilities):
value = getattr(horton_object.capabilities, flag_name)
if not callable(value):
if not value:
horton_object.skip_list.append(flag_name)
def get_module_client(settings_object):
"""
get a module client for the given settings object
"""
client = adapters.create_adapter(settings_object.adapter_address,
"module_client")
client.device_id = settings_object.device_id
client.module_id = settings_object.module_id
client.capabilities = settings_object.capabilities
if settings_object.capabilities.v2_connect_group:
if settings_object.connection_type == "environment":
client.create_from_environment_sync(settings_object.transport)
else:
client.create_from_connection_string_sync(
settings_object.transport,
settings_object.connection_string,
get_ca_cert(settings_object),
)
else:
if settings_object.connection_type == "environment":
client.connect_from_environment_sync(settings_object.transport)
else:
client.connect_sync(
settings_object.transport,
settings_object.connection_string,
get_ca_cert(settings_object),
)
return client
async def _get_service_client_adapter(settings_object):
"""
connect the client for the ServiceClient implementation we're using return the client object
"""
adapter = adapters.create_adapter(settings_object.adapter_address,
"service")
await adapter.connect(settings_object.connection_string)
return adapter
def connect_registry_client():
"""
connect the module client for the Registry implementation we're using return the client object
"""
client = adapters.create_adapter(settings.registry.adapter_address,
"registry")
client.connect_sync(settings.registry.connection_string)
return client
def eventhub(logger):
eventhub = adapters.create_adapter(settings.eventhub.adapter_address,
"eventhub")
eventhub.create_from_connection_string_sync(
settings.eventhub.connection_string)
yield eventhub
logger(separator.format("eventhub"))
eventhub.disconnect_sync()
def connect_service_client():
"""
connect the module client for the ServiceClient implementation we're using return the client object
"""
client = adapters.create_adapter(settings.service.adapter_address,
"service")
client.connect_sync(settings.service.connection_string)
return client
def get_net_control_api():
"""
return an object that can be used to control the network
"""
api = adapters.create_adapter(settings.net_control.adapter_address, "net")
api.set_destination_sync(settings.net_control.test_destination,
settings.test_module.transport)
return api
async def _get_registry_client_adapter(settings_object):
"""
connect the client adapter for the Registry implementation we're using
"""
adapter = adapters.create_adapter(settings_object.adapter_address,
"registry")
await adapter.connect(settings_object.connection_string)
return adapter
async def _get_system_control_adapter(settings_object):
"""
return an object that can be used to control the operating system
"""
adapter = adapters.create_adapter(settings_object.adapter_address,
"system_control")
await adapter.set_network_destination(settings_object.test_destination,
settings.test_module.transport)
return adapter
async def _get_eventhub_client_adapter(settings_object):
"""
get an eventhub client adapter that we can use to watch telemetry operations
"""
adapter = adapters.create_adapter(settings_object.adapter_address,
"eventhub")
await adapter.create_from_connection_string(
settings_object.connection_string)
return adapter
def set_logger():
settings.test_module.wrapper_api = adapters.create_adapter(
settings.test_module.adapter_address, "wrapper")
def print_and_log(message):
if settings.test_module.adapter_address != "direct_python":
print(message)
settings.test_module.wrapper_api.log_message_sync(message)
adapter_config.logger = print_and_log
def eventhub(logger):
eventhub = adapters.create_adapter(settings.eventhub.adapter_address,
"eventhub")
eventhub.create_from_connection_string_sync(
settings.eventhub.connection_string)
yield eventhub
logger(separator.format("eventhub"))
try:
eventhub.disconnect_sync()
except Exception as e:
logger("exception disconnecting eventhub: {}".format(e))
def connect_test_device_client():
"""
connect the device client for the test device and return the client object
"""
client = adapters.create_adapter(settings.test_device.adapter_address,
"device_client")
client.device_id = settings.test_device.device_id
client.connect_sync(settings.test_device.transport,
settings.test_device.connection_string, {})
return client
def set_logger():
# BKTODO: output to more than test_module
# BKTODO: control_api
settings.test_module.wrapper_api = adapters.create_adapter(
settings.test_module.adapter_address, "wrapper")
def print_and_log(message):
if settings.test_module.adapter_address != "python_inproc":
print(message)
settings.test_module.wrapper_api.log_message_sync(message)
adapters.adapter_config.logger_function = print_and_log
async def eventhub(event_loop):
eventhub = adapters.create_adapter(settings.eventhub.adapter_address,
"eventhub")
await eventhub.create_from_connection_string(
settings.eventhub.connection_string)
try:
yield eventhub
finally:
logger(separator("eventhub finalizer"))
try:
await eventhub.disconnect()
except Exception as e:
logger("exception disconnecting eventhub: {}".format(e))
async def _get_device_client_adapter(settings_object):
"""
get a device client adapter for the given settings object
"""
if not settings_object.device_id and not settings_object.id_scope:
return None
adapter = adapters.create_adapter(settings_object.adapter_address,
"device_client")
adapter.device_id = settings_object.device_id
return adapter
async def _get_module_client_adapter(settings_object):
"""
get a module client adapter for the given settings object
"""
if not settings_object.device_id or not settings_object.module_id:
return None
adapter = adapters.create_adapter(settings_object.adapter_address,
"module_client")
adapter.device_id = settings_object.device_id
adapter.module_id = settings_object.module_id
return adapter
def collect_capabilities(horton_object):
if horton_object.device_id:
horton_object.wrapper_api = adapters.create_adapter(
horton_object.adapter_address, "wrapper")
try:
caps = horton_object.wrapper_api.get_capabilities_sync()
except (HttpOperationError, ClientRequestError):
caps = None
horton_object.capabilities = HortonCapabilities()
if caps:
flags = caps["flags"]
for flag_name in flags:
setattr(horton_object.capabilities, flag_name,
flags[flag_name])
def connect_leaf_device_client():
"""
connect the device client for the leaf device and return the client object
"""
client = adapters.create_adapter(settings.leaf_device.adapter_address,
"device_client")
client.device_id = settings.leaf_device.device_id
client.connect_sync(
settings.leaf_device.transport,
settings.leaf_device.connection_string,
get_ca_cert(settings.leaf_device),
)
return client
def connect_friend_module_client():
"""
connect the module client for the friend module and return the client object
"""
client = adapters.create_adapter(settings.friend_module.adapter_address,
"module_client")
client.device_id = settings.friend_module.device_id
client.module_id = settings.friend_module.module_id
if settings.friend_module.connection_type == "environment":
client.connect_from_environment_sync(settings.friend_module.transport)
else:
client.connect_sync(
settings.friend_module.transport,
settings.friend_module.connection_string,
get_ca_cert(settings.friend_module),
)
return client
def collect_capabilities(horton_object):
if horton_object.device_id:
horton_object.wrapper_api = adapters.create_adapter(
horton_object.adapter_address, "wrapper"
)
try:
caps = horton_object.wrapper_api.get_capabilities_sync()
except (HttpOperationError, ClientRequestError):
caps = None
horton_object.capabilities = HortonCapabilities()
if caps:
flags = caps["flags"]
for flag_name in flags:
setattr(horton_object.capabilities, flag_name, flags[flag_name])
horton_object.skip_list = list(caps["skip_list"])
else:
horton_object.skip_list = hardcoded_skip_list[horton_object.language]
for flag_name in dir(horton_object.capabilities):
value = getattr(horton_object.capabilities, flag_name)
if not callable(value):
if not value:
horton_object.skip_list.append(flag_name)
