def _device_interface_elements(cmd, device_id, interface, target_type,
hub_name, resource_group_name, login):
discovery = IotHubDiscovery(cmd)
target = discovery.get_target(hub_name=hub_name,
resource_group_name=resource_group_name,
login=login)
service_sdk, errors = _bind_sdk(target, SdkType.service_sdk)
interface_elements = []
try:
payload = {"id": {}}
payload["id"] = interface
target_payload = shell_safe_json_parse(str(payload))
interface_def = service_sdk.invoke_interface_command(
device_id, INTERFACE_MODELDEFINITION, INTERFACE_COMMANDNAME,
target_payload)
if interface_def and interface_def.get("contents"):
interface_contents = interface_def.get("contents")
for content in interface_contents:
if isinstance(content.get("@type"),
list) and target_type in content.get("@type"):
interface_elements.append(content)
elif content.get("@type") == target_type:
interface_elements.append(content)
return interface_elements
except errors.CloudError as e:
raise CLIError(unpack_msrest_error(e))
except Exception:
# returning an empty collection to continue
return []
def test_get_target_by_cstring(self, fixture_cmd, get_mgmt_client):
discovery = IotHubDiscovery(cmd=fixture_cmd)
fake_login = (
"HostName=CoolIoTHub.azure-devices.net;SharedAccessKeyName=iothubowner;"
"SharedAccessKey=AB+c/+5nm2XpDXcffhnGhnxz/TVF4m5ag7AuVIGwchj="
)
parsed_fake_login = parse_iot_hub_connection_string(fake_login)
target = discovery.get_target(
hub_name=None, resource_group_name=None, login=fake_login
)
# Ensure no ARM calls are made
assert get_mgmt_client.call_count == 0
assert target["cs"] == fake_login
assert target["entity"] == parsed_fake_login["HostName"]
assert target["policy"] == parsed_fake_login["SharedAccessKeyName"]
assert target["primarykey"] == parsed_fake_login["SharedAccessKey"]
target = discovery.get_target_by_cstring(fake_login)
# Ensure no ARM calls are made
assert get_mgmt_client.call_count == 0
assert target["cs"] == fake_login
assert target["entity"] == parsed_fake_login["HostName"]
assert target["policy"] == parsed_fake_login["SharedAccessKeyName"]
assert target["primarykey"] == parsed_fake_login["SharedAccessKey"]
def iot_digitaltwin_property_update(
cmd,
interface_payload,
device_id,
hub_name=None,
resource_group_name=None,
login=None,
):
if exists(interface_payload):
interface_payload = str(read_file_content(interface_payload))
target_json = None
try:
target_json = shell_safe_json_parse(interface_payload)
except ValueError:
pass
if target_json:
interface_payload = target_json
discovery = IotHubDiscovery(cmd)
target = discovery.get_target(hub_name=hub_name,
resource_group_name=resource_group_name,
login=login)
service_sdk, errors = _bind_sdk(target, SdkType.service_sdk)
try:
result = service_sdk.update_interfaces(device_id,
interfaces=interface_payload)
return result
except errors.CloudError as e:
raise CLIError(unpack_msrest_error(e))
def test_iothub_targets(self):
discovery = IotHubDiscovery(self.cmd_shell)
cs_target1 = discovery.get_target_by_cstring(self.connection_string)
assert_target(cs_target1, True)
cs_target2 = discovery.get_target(hub_name=None,
login=self.connection_string)
assert_target(cs_target2, True)
auto_target = discovery.get_target(hub_name=LIVE_HUB)
assert_target(auto_target, rg=LIVE_RG)
auto_target = discovery.get_target(hub_name=LIVE_HUB, rg=LIVE_RG)
assert_target(auto_target, rg=LIVE_RG)
desired_target = discovery.get_target(
hub_name=LIVE_HUB,
policy_name=self.desired_policy_name,
include_events=True)
assert_target(desired_target, rg=LIVE_RG, include_events=True)
sub_targets = discovery.get_targets()
[assert_target(tar) for tar in sub_targets]
rg_targets = discovery.get_targets(rg=LIVE_RG, include_events=True)
[
assert_target(tar, rg=LIVE_RG, include_events=True)
for tar in rg_targets
]
assert len(rg_targets) <= len(sub_targets)
def __init__(self, cmd, hub_name, rg, login=None):
self.cmd = cmd
self.hub_name = hub_name
self.rg = rg
self.discovery = IotHubDiscovery(cmd)
self.target = self.discovery.get_target(
hub_name=self.hub_name,
rg=self.rg,
login=login,
)
self.resolver = SdkResolver(self.target)
def iot_digitaltwin_invoke_command(
cmd,
interface,
device_id,
command_name,
command_payload=None,
timeout=10,
hub_name=None,
resource_group_name=None,
login=None,
):
device_interfaces = _iot_digitaltwin_interface_list(
cmd, device_id, hub_name, resource_group_name, login)
interface_list = _get_device_default_interface_dict(device_interfaces)
target_interface = next(
(item for item in interface_list if item["name"] == interface), None)
if not target_interface:
raise CLIError("Target interface is not implemented by the device!")
if command_payload:
if exists(command_payload):
command_payload = str(read_file_content(command_payload))
target_json = None
try:
target_json = shell_safe_json_parse(command_payload)
except ValueError:
pass
if target_json or isinstance(target_json, bool):
command_payload = target_json
discovery = IotHubDiscovery(cmd)
target = discovery.get_target(hub_name=hub_name,
resource_group_name=resource_group_name,
login=login)
service_sdk, errors = _bind_sdk(target, SdkType.service_sdk)
try:
result = service_sdk.invoke_interface_command(
device_id,
interface,
command_name,
command_payload,
connect_timeout_in_seconds=timeout,
response_timeout_in_seconds=timeout,
)
return result
except errors.CloudError as e:
raise CLIError(unpack_msrest_error(e))
def _iot_digitaltwin_interface_list(cmd,
device_id,
hub_name=None,
resource_group_name=None,
login=None):
discovery = IotHubDiscovery(cmd)
target = discovery.get_target(hub_name=hub_name,
resource_group_name=resource_group_name,
login=login)
service_sdk, errors = _bind_sdk(target, SdkType.service_sdk)
try:
device_interfaces = service_sdk.get_interfaces(device_id)
return device_interfaces
except errors.CloudError as e:
raise CLIError(unpack_msrest_error(e))
def _ensure_dps_hub_link(self, dps, rg, hub):
cli = embedded_cli.EmbeddedCLI()
hubs = cli.invoke("iot dps linked-hub list --dps-name {} -g {}".format(
dps, rg)).as_json()
if not len(hubs) or not len(
list(
filter(
lambda linked_hub: linked_hub["name"] ==
"{}.azure-devices.net".format(hub),
hubs,
))):
discovery = IotHubDiscovery(self.cmd_shell)
target_hub = discovery.get_target(hub, rg)
cli.invoke(
"iot dps linked-hub create --dps-name {} -g {} --connection-string {} --location {}"
.format(dps, rg, target_hub.get("cs"), target_hub.get("location")))
def __init__(self,
cmd,
hub_name,
rg,
login=None,
auth_type_dataplane=None):
self.cmd = cmd
self.hub_name = hub_name
self.rg = rg
self.discovery = IotHubDiscovery(cmd)
self.target = self.discovery.get_target(
hub_name=self.hub_name,
resource_group_name=self.rg,
login=login,
auth_type=auth_type_dataplane,
)
self.resolver = SdkResolver(self.target)
def test_iothub_discovery(self):
discovery = IotHubDiscovery(self.cmd_shell)
iothub = discovery.find_iothub(hub_name=LIVE_HUB)
assert iothub.name == LIVE_HUB
auto_policy = discovery.find_policy(hub_name=LIVE_HUB,
rg=LIVE_RG).as_dict()
rights_set = set(auto_policy["rights"].split(", "))
assert rights_set == PRIVILEDGED_ACCESS_RIGHTS_SET
# Assumption - Test Iothub includes the vanilla iothubowner policy
desired_policy = discovery.find_policy(
hub_name=LIVE_HUB,
rg=LIVE_RG,
policy_name=self.desired_policy_name).as_dict()
assert desired_policy["key_name"] == self.desired_policy_name
policies = discovery.get_policies(hub_name=LIVE_HUB, rg=LIVE_RG)
assert len(policies)
# Example for leveraging discovery to build cstring for every policy on target IotHub
cstrings = [
discovery._build_target(iothub=iothub, policy=p)["cs"]
for p in policies
]
assert len(cstrings)
sub_hubs = discovery.get_iothubs()
assert sub_hubs
filtered_sub_hubs = [
hub for hub in sub_hubs if hub.as_dict()["name"] == LIVE_HUB
]
assert filtered_sub_hubs
rg_hubs = discovery.get_iothubs(rg=LIVE_RG)
assert rg_hubs
filtered_rg_hubs = [
hub for hub in rg_hubs if hub.as_dict()["name"] == LIVE_HUB
]
assert filtered_rg_hubs
assert len(rg_hubs) <= len(sub_hubs)
class IoTHubProvider(object):
def __init__(self, cmd, hub_name, rg, login=None):
self.cmd = cmd
self.hub_name = hub_name
self.rg = rg
self.discovery = IotHubDiscovery(cmd)
self.target = self.discovery.get_target(
hub_name=self.hub_name,
rg=self.rg,
login=login,
)
self.resolver = SdkResolver(self.target)
def get_sdk(self, sdk_type):
return self.resolver.get_sdk(sdk_type)