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)