def iothub_registrymanager_sample_run():
try:
# RegistryManager
iothub_registry_manager = IoTHubRegistryManager(CONNECTION_STRING)
# CreateDevice
primary_key = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnoo"
secondary_key = "111222333444555666777888999000aaabbbcccdddee"
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
new_device = iothub_registry_manager.create_device(DEVICE_ID, primary_key, secondary_key, auth_method)
print_device_info("CreateDevice", new_device)
# GetDevice
iothub_device = iothub_registry_manager.get_device(DEVICE_ID)
print_device_info("GetDevice", iothub_device)
# UpdateDevice
primary_key = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
secondary_key = "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy"
status = IoTHubDeviceStatus.DISABLED
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager.update_device(DEVICE_ID, primary_key, secondary_key, status, auth_method)
updated_device = iothub_registry_manager.get_device(DEVICE_ID)
print_device_info("UpdateDevice", updated_device)
# DeleteDevice
print ( "DeleteDevice" )
iothub_registry_manager.delete_device(DEVICE_ID)
print ( "" )
# GetDeviceList
print ( "GetDeviceList" )
number_of_devices = 3
dev_list = iothub_registry_manager.get_device_list(number_of_devices)
number_of_devices = len(dev_list)
print ( "Number of devices : {0}".format(number_of_devices) )
for device in range(0, number_of_devices):
title = "Device " + str(device)
print_device_info(title, dev_list[device])
print ( "" )
# GetStatistics
iothub_registry_statistics = iothub_registry_manager.get_statistics()
print ( "GetStatistics" )
print ( "Total device count : {0}".format(iothub_registry_statistics.totalDeviceCount) )
print ( "Enabled device count : {0}".format(iothub_registry_statistics.enabledDeviceCount) )
print ( "Disabled device count : {0}".format(iothub_registry_statistics.disabledDeviceCount) )
print ( "" )
except IoTHubError as iothub_error:
print ( "Unexpected error {0}".format(iothub_error) )
return
except KeyboardInterrupt:
print ( "IoTHubRegistryManager sample stopped" )
def run_e2e_messaging(iothub_connection_string):
global RECEIVE_CALLBACKS
global MESSAGING_MESSAGE
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager = IoTHubRegistryManager(
iothub_connection_string)
new_device = iothub_registry_manager.create_device(
device_id, primary_key, secondary_key, auth_method)
protocol = IoTHubTransportProvider.MQTT
connection_string = get_connection_string(iothub_registry_manager,
IOTHUB_CONNECTION_STRING,
device_id, False)
device_client = IoTHubClient(connection_string, protocol)
assert isinstance(device_client,
IoTHubClient), 'Invalid type returned!'
assert device_client != None, "device_client is NULL"
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
device_client.set_message_callback(receive_message_callback,
MESSAGING_CONTEXT)
###########################################################################
# IoTHubMessaging
# prepare
# act
iothub_messaging = IoTHubMessaging(IOTHUB_CONNECTION_STRING)
# verify
assert iothub_messaging != None, "iothub_messaging is NULL"
###########################################################################
# Wait before open...
sleep_before_device_action()
############################################################################
# open
# act
iothub_messaging.open(open_complete_callback, None)
############################################################################
############################################################################
# invoke
# prepare
MESSAGING_MESSAGE = ''.join(
[random.choice(string.ascii_letters) for n in range(12)])
message = IoTHubMessage(bytearray(MESSAGING_MESSAGE, 'utf8'))
iothub_messaging.send_async(device_id, message, send_complete_callback,
MESSAGING_CONTEXT)
MESSAGE_RECEIVED_EVENT.wait(MESSAGE_RECEIVE_CALLBACK_TIMEOUT)
# verify
assert RECEIVE_CALLBACKS == 1, "message has not been received"
############################################################################
print("")
retval = 0
except Exception as e:
print("")
print("run_e2e_messaging() failed with exception: {0}".format(e))
retval = 1
finally:
# clean-up
iothub_messaging.close()
iothub_registry_manager.delete_device(device_id)
return retval
def run_e2e_method(iothub_connection_string, testing_modules):
global DEVICE_METHOD_USER_CONTEXT
global DEVICE_METHOD_NAME
global DEVICE_METHOD_PAYLOAD
global DEVICE_METHOD_TIMEOUT
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager = IoTHubRegistryManager(
iothub_connection_string)
new_device = iothub_registry_manager.create_device(
device_id, primary_key, secondary_key, auth_method)
if testing_modules == True:
new_module = iothub_registry_manager.create_module(
device_id, primary_key, secondary_key, TEST_MODULE_ID,
auth_method)
protocol = IoTHubTransportProvider.AMQP
else:
protocol = IoTHubTransportProvider.MQTT
connection_string = get_connection_string(iothub_registry_manager,
IOTHUB_CONNECTION_STRING,
device_id, testing_modules)
device_client = IoTHubClient(connection_string, protocol)
assert isinstance(device_client,
IoTHubClient), 'Invalid type returned!'
assert device_client != None, "device_client is NULL"
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
device_client.set_device_method_callback(device_method_callback,
DEVICE_METHOD_USER_CONTEXT)
###########################################################################
# IoTHubDeviceMethod
# prepare
# act
iothub_device_method = IoTHubDeviceMethod(IOTHUB_CONNECTION_STRING)
# verify
assert iothub_device_method != None, "iothub_device_method is NULL"
###########################################################################
# Wait before invoke...
sleep_before_device_action()
############################################################################
# invoke
# prepare
# act
if testing_modules == True:
response = iothub_device_method.invoke(device_id, TEST_MODULE_ID,
DEVICE_METHOD_NAME,
DEVICE_METHOD_PAYLOAD,
DEVICE_METHOD_TIMEOUT)
else:
response = iothub_device_method.invoke(device_id,
DEVICE_METHOD_NAME,
DEVICE_METHOD_PAYLOAD,
DEVICE_METHOD_TIMEOUT)
assert response != None, "response is NULL"
assert isinstance(response,
IoTHubDeviceMethodResponse), 'Invalid type returned!'
# verify
response_ok = response.payload.find(DEVICE_CLIENT_RESPONSE)
assert response_ok > 0, "response does not contain " + DEVICE_CLIENT_RESPONSE
assert response.status == 200, "response status is : " + response.status
DEVICE_METHOD_EVENT.wait(DEVICE_METHOD_CALLBACK_TIMEOUT)
assert DEVICE_CLIENT_RESPONSE.find(
DEVICE_METHOD_RESPONSE_PREFIX
) >= 0, "Timeout expired and device method has not been called!"
############################################################################
print("")
retval = 0
except Exception as e:
print("")
print("run_e2e_method() failed with exception: {0}".format(e))
retval = 1
finally:
# clean-up
iothub_registry_manager.delete_device(device_id)
return retval
def run_e2e_twin(iothub_connection_string, testing_modules):
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager = IoTHubRegistryManager(
iothub_connection_string)
new_device = iothub_registry_manager.create_device(
device_id, primary_key, secondary_key, auth_method)
if testing_modules == True:
new_module = iothub_registry_manager.create_module(
device_id, primary_key, secondary_key, TEST_MODULE_ID,
auth_method)
###########################################################################
# IoTHubDeviceTwin
# act
iothub_device_twin = IoTHubDeviceTwin(IOTHUB_CONNECTION_STRING)
# verify
assert iothub_device_twin != None, "iothub_device_twin is NULL"
###########################################################################
###########################################################################
# Wait before get twin...
sleep_before_device_action()
###########################################################################
# get_twin
# act
if testing_modules == True:
twin_info = iothub_device_twin.get_twin(device_id, TEST_MODULE_ID)
else:
twin_info = iothub_device_twin.get_twin(device_id)
# verify
assert twin_info != None, "twin_info is NULL"
json_ok = twin_info.find("deviceId")
assert json_ok > 0, "twin_info does not contain deviceId tag"
json_ok = twin_info.find(device_id)
assert json_ok > 0, "twin_info does not contain the correct device id"
if testing_modules == True:
json_ok = twin_info.find("moduleId")
assert json_ok > 0, "twin_info does not contain moduleId tag"
json_ok = twin_info.find("etag")
assert json_ok > 0, "twin_info does not contain etag tag"
json_ok = twin_info.find("properties")
assert json_ok > 0, "twin_info does not contain properties tag"
###########################################################################
print("")
print("Twin before update:")
print("{0}".format(twin_info))
###########################################################################
# update_twin
# prepare
new_property_name = "telemetryInterval"
new_property_value = "42"
UPDATE_JSON = "{\"properties\":{\"desired\":{\"" + new_property_name + "\":" + new_property_value + "}}}"
# act
if testing_modules == True:
twin_info = iothub_device_twin.update_twin(device_id,
TEST_MODULE_ID,
UPDATE_JSON)
else:
twin_info = iothub_device_twin.update_twin(device_id, UPDATE_JSON)
# verify
assert twin_info != None, "twin_info is NULL"
json_ok = twin_info.find("deviceId")
assert json_ok > 0, "twin_info does not contain deviceId tag"
json_ok = twin_info.find(device_id)
assert json_ok > 0, "twin_info does not contain the correct device id"
json_ok = twin_info.find("etag")
assert json_ok > 0, "twin_info does not contain etag tag"
json_ok = twin_info.find("properties")
assert json_ok > 0, "twin_info does not contain properties tag"
json_ok = twin_info.find(new_property_name)
assert json_ok > 0, "twin_info does not contain " + new_property_name + " tag"
json_ok = twin_info.find(new_property_value)
assert json_ok > 0, "twin_info does not contain " + new_property_value
###########################################################################
print("")
print("Device Twin after update:")
print("{0}".format(twin_info))
print("")
retval = 0
except Exception as e:
print("")
print("run_e2e_twin() failed with exception: {0}".format(e))
retval = 1
finally:
# clean-up
if testing_modules == True:
iothub_registry_manager.delete_module(device_id, TEST_MODULE_ID)
iothub_registry_manager.delete_device(device_id)
return retval
def run_e2e_registrymanager(iothub_connection_string):
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
###########################################################################
# IoTHubRegistryManager
# prepare
# act
iothub_registry_manager = IoTHubRegistryManager(
iothub_connection_string)
# verify
assert isinstance(iothub_registry_manager,
IoTHubRegistryManager), 'Invalid type returned!'
assert iothub_registry_manager != None, "iothub_registry_manager is NULL"
###########################################################################
print("IoTHubRegistryManager is created successfully")
###########################################################################
# create_device
# prepare
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
# act
new_device = iothub_registry_manager.create_device(
device_id, primary_key, secondary_key, auth_method)
# verify
assert isinstance(new_device, IoTHubDevice), 'Invalid type returned!'
assert new_device != None, "new_device is NULL"
assert new_device.primaryKey != None, "new_device.primaryKey is NULL"
assert new_device.primaryKey != "", "new_device.primaryKey is empty"
assert new_device.secondaryKey != None, "new_device.secondaryKey is NULL"
assert new_device.secondaryKey != "", "new_device.secondaryKey is empty"
###########################################################################
print_device_or_module_info("CreateDevice", new_device, False)
###########################################################################
# create_module_device
# prepare
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
# act
new_module = iothub_registry_manager.create_module(
device_id, primary_key, secondary_key, TEST_MODULE_ID, auth_method)
# verify
assert isinstance(new_module, IoTHubModule), 'Invalid type returned!'
assert new_module != None, "new_module is NULL"
assert new_module.primaryKey != None, "new_module.primaryKey is NULL"
assert new_module.primaryKey != "", "new_module.primaryKey is empty"
assert new_module.secondaryKey != None, "new_module.secondaryKey is NULL"
assert new_module.secondaryKey != "", "new_module.secondaryKey is empty"
###########################################################################
print_device_or_module_info("CreateModule", new_module, True)
###########################################################################
# get_device
get_device_info_and_verify("GetDevice", iothub_registry_manager,
device_id)
###########################################################################
# get_module
get_module_info_and_verify("GetModule", iothub_registry_manager,
device_id)
###########################################################################
# update_device
# prepare
primary_key = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(44)
])
secondary_key = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(44)
])
status = IoTHubDeviceStatus.DISABLED
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
# act
iothub_registry_manager.update_device(device_id, primary_key,
secondary_key, status,
auth_method)
# verify
get_device_info_and_verify("UpdateDevice", iothub_registry_manager,
device_id)
###########################################################################
# update_module
# prepare
primary_key = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(44)
])
secondary_key = ''.join([
random.choice(string.ascii_letters + string.digits)
for n in range(44)
])
status = IoTHubDeviceStatus.DISABLED
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
# act
iothub_registry_manager.update_module(device_id, primary_key,
secondary_key, TEST_MODULE_ID,
auth_method)
# verify
get_module_info_and_verify("UpdateModule", iothub_registry_manager,
device_id)
###########################################################################
# get_device_list
# prepare
req_number_of_devices = 10
# act
device_list = iothub_registry_manager.get_device_list(
req_number_of_devices)
# verify
assert device_list != None, "device_list is NULL"
number_of_devices = len(device_list)
assert number_of_devices != None, "device_list is NULL"
assert number_of_devices > 0, "number_of_devices is incorrect"
###########################################################################
print("Number of devices : {0}".format(
number_of_devices))
###########################################################################
# get_statistics
# prepare
# act
iothub_registry_statistics = iothub_registry_manager.get_statistics()
# verify
assert iothub_registry_statistics.totalDeviceCount >= 0, "iothub_registry_statistics.totalDeviceCount is incorrect"
sum_device_count = iothub_registry_statistics.enabledDeviceCount + iothub_registry_statistics.disabledDeviceCount
assert sum_device_count >= 0, "iothub_registry_statistics.totalDeviceCount is incorrect"
###########################################################################
print("GetStatistics")
print("Total device count : {0}".format(
iothub_registry_statistics.totalDeviceCount))
print("Enabled device count : {0}".format(
iothub_registry_statistics.enabledDeviceCount))
print("Disabled device count : {0}".format(
iothub_registry_statistics.disabledDeviceCount))
retval = 0
except Exception as e:
print("")
print("run_e2e_registrymanager() failed with exception: {0}".format(e))
retval = 1
finally:
###########################################################################
# delete_module
# prepare
# act
iothub_registry_manager.delete_module(device_id, TEST_MODULE_ID)
# verify
###########################################################################
# delete_device
# prepare
# act
iothub_registry_manager.delete_device(device_id)
# verify
###########################################################################
return retval
def run_e2e_messaging(iothub_connection_string):
global RECEIVE_CALLBACKS
global MESSAGING_MESSAGE
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager = IoTHubRegistryManager(iothub_connection_string)
new_device = iothub_registry_manager.create_device(device_id, primary_key, secondary_key, auth_method)
device_connection_string = get_device_connection_string(iothub_registry_manager, IOTHUB_CONNECTION_STRING, device_id)
device_client = IoTHubClient(device_connection_string, IoTHubTransportProvider.MQTT)
assert isinstance(device_client, IoTHubClient), 'Invalid type returned!'
assert device_client != None, "device_client is NULL"
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
device_client.set_message_callback(receive_message_callback, MESSAGING_CONTEXT)
###########################################################################
# IoTHubMessaging
# prepare
# act
iothub_messaging = IoTHubMessaging(IOTHUB_CONNECTION_STRING)
# verify
assert iothub_messaging != None, "iothub_messaging is NULL"
###########################################################################
# Wait before open...
time.sleep(SLEEP_BEFORE_DEVICE_ACTION)
############################################################################
# open
# act
iothub_messaging.open(open_complete_callback, None)
############################################################################
############################################################################
# invoke
# prepare
MESSAGING_MESSAGE = ''.join([random.choice(string.ascii_letters) for n in range(12)])
message = IoTHubMessage(bytearray(MESSAGING_MESSAGE, 'utf8'))
# act
iothub_messaging.send_async(device_id, message, send_complete_callback, MESSAGING_CONTEXT)
MESSAGE_RECEIVED_EVENT.wait(MESSAGE_RECEIVE_CALLBACK_TIMEOUT)
# verify
assert RECEIVE_CALLBACKS == 1, "message has not been received"
############################################################################
print ( "" )
retval = 0
except Exception as e:
print ( "" )
print ("run_e2e_messaging() failed with exception: {0}".format(e))
retval = 1
finally:
# clean-up
iothub_messaging.close()
iothub_registry_manager.delete_device(device_id)
return retval
def run_e2e_devicemethod(iothub_connection_string):
global DEVICE_METHOD_USER_CONTEXT
global DEVICE_METHOD_NAME
global DEVICE_METHOD_PAYLOAD
global DEVICE_METHOD_TIMEOUT
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager = IoTHubRegistryManager(iothub_connection_string)
new_device = iothub_registry_manager.create_device(device_id, primary_key, secondary_key, auth_method)
device_connection_string = get_device_connection_string(iothub_registry_manager, IOTHUB_CONNECTION_STRING, device_id)
device_client = IoTHubClient(device_connection_string, IoTHubTransportProvider.MQTT)
assert isinstance(device_client, IoTHubClient), 'Invalid type returned!'
assert device_client != None, "device_client is NULL"
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
device_client.set_device_method_callback(device_method_callback, DEVICE_METHOD_USER_CONTEXT)
###########################################################################
# IoTHubDeviceMethod
# prepare
# act
iothub_device_method = IoTHubDeviceMethod(IOTHUB_CONNECTION_STRING)
# verify
assert iothub_device_method != None, "iothub_device_method is NULL"
###########################################################################
# Wait before invoke...
time.sleep(SLEEP_BEFORE_DEVICE_ACTION)
############################################################################
# invoke
# prepare
# act
response = iothub_device_method.invoke(device_id, DEVICE_METHOD_NAME, DEVICE_METHOD_PAYLOAD, DEVICE_METHOD_TIMEOUT)
assert response != None, "response is NULL"
assert isinstance(response, IoTHubDeviceMethodResponse), 'Invalid type returned!'
# verify
response_ok = response.payload.find(DEVICE_CLIENT_RESPONSE)
assert response_ok > 0, "response does not contain " + DEVICE_CLIENT_RESPONSE
assert response.status == 200, "response status is : " + response.status
DEVICE_METHOD_EVENT.wait(DEVICE_METHOD_CALLBACK_TIMEOUT)
assert DEVICE_CLIENT_RESPONSE.find(DEVICE_METHOD_RESPONSE_PREFIX) >= 0, "Timeout expired and device method has not been called!"
############################################################################
print ( "" )
retval = 0
except Exception as e:
print ( "" )
print ("run_e2e_devicemethod() failed with exception: {0}".format(e))
retval = 1
finally:
# clean-up
iothub_registry_manager.delete_device(device_id)
return retval
def run_e2e_devicetwin(iothub_connection_string):
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager = IoTHubRegistryManager(iothub_connection_string)
new_device = iothub_registry_manager.create_device(device_id, primary_key, secondary_key, auth_method)
###########################################################################
# IoTHubDeviceTwin
# act
iothub_device_twin = IoTHubDeviceTwin(IOTHUB_CONNECTION_STRING)
# verify
assert iothub_device_twin != None, "iothub_device_twin is NULL"
###########################################################################
###########################################################################
# Wait before get twin...
time.sleep(SLEEP_BEFORE_DEVICE_ACTION)
###########################################################################
# get_twin
# act
twin_info = iothub_device_twin.get_twin(device_id)
# verify
assert twin_info != None, "twin_info is NULL"
json_ok = twin_info.find("deviceId")
assert json_ok > 0, "twin_info does not contain deviceId tag"
json_ok = twin_info.find(device_id)
assert json_ok > 0, "twin_info does not contain the correct device id"
json_ok = twin_info.find("etag")
assert json_ok > 0, "twin_info does not contain etag tag"
json_ok = twin_info.find("properties")
assert json_ok > 0, "twin_info does not contain properties tag"
###########################################################################
print ( "" )
print ( "Device Twin before update:" )
print ( "{0}".format(twin_info) )
###########################################################################
# update_twin
# prepare
new_property_name = "telemetryInterval"
new_property_value = "42"
UPDATE_JSON = "{\"properties\":{\"desired\":{\"" + new_property_name + "\":" + new_property_value + "}}}"
# act
twin_info = iothub_device_twin.update_twin(device_id, UPDATE_JSON)
# verify
assert twin_info != None, "twin_info is NULL"
json_ok = twin_info.find("deviceId")
assert json_ok > 0, "twin_info does not contain deviceId tag"
json_ok = twin_info.find(device_id)
assert json_ok > 0, "twin_info does not contain the correct device id"
json_ok = twin_info.find("etag")
assert json_ok > 0, "twin_info does not contain etag tag"
json_ok = twin_info.find("properties")
assert json_ok > 0, "twin_info does not contain properties tag"
json_ok = twin_info.find(new_property_name)
assert json_ok > 0, "twin_info does not contain " + new_property_name + " tag"
json_ok = twin_info.find(new_property_value)
assert json_ok > 0, "twin_info does not contain " + new_property_value
###########################################################################
print ( "" )
print ( "Device Twin after update:" )
print ( "{0}".format(twin_info) )
print ( "" )
retval = 0
except Exception as e:
print ( "" )
print ("run_e2e_devicetwin() failed with exception: {0}".format(e))
retval = 1
finally:
# clean-up
iothub_registry_manager.delete_device(device_id)
return retval
def run_e2e_registrymanager(iothub_connection_string):
try:
# prepare
device_id = generate_device_name()
assert isinstance(device_id, str), 'Invalid type returned!'
###########################################################################
# IoTHubRegistryManager
# prepare
# act
iothub_registry_manager = IoTHubRegistryManager(iothub_connection_string)
# verify
assert isinstance(iothub_registry_manager, IoTHubRegistryManager), 'Invalid type returned!'
assert iothub_registry_manager != None, "iothub_registry_manager is NULL"
###########################################################################
print ( "IoTHubRegistryManager is created successfully" )
###########################################################################
# create_device
# prepare
primary_key = ""
secondary_key = ""
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
# act
new_device = iothub_registry_manager.create_device(device_id, primary_key, secondary_key, auth_method)
# verify
assert isinstance(new_device, IoTHubDevice), 'Invalid type returned!'
assert new_device != None, "new_device is NULL"
assert new_device.primaryKey != None, "new_device.primaryKey is NULL"
assert new_device.primaryKey != "", "new_device.primaryKey is empty"
assert new_device.secondaryKey != None, "new_device.secondaryKey is NULL"
assert new_device.secondaryKey != "", "new_device.secondaryKey is empty"
###########################################################################
print_device_info("CreateDevice", new_device)
###########################################################################
# get_device
# prepare
# act
iothub_device = iothub_registry_manager.get_device(device_id)
# verify
assert isinstance(iothub_device, IoTHubDevice), 'Invalid type returned!'
assert iothub_device != None, "iothub_device is NULL"
assert iothub_device.primaryKey != None, "iothub_device.primaryKey is NULL"
assert iothub_device.primaryKey != "", "iothub_device.primaryKey is empty"
assert iothub_device.secondaryKey != None, "iothub_device.secondaryKey is NULL"
assert iothub_device.secondaryKey != "", "iothub_device.secondaryKey is empty"
###########################################################################
print_device_info("GetDevice", iothub_device)
###########################################################################
# update_device
# prepare
primary_key = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(44)])
secondary_key = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(44)])
status = IoTHubDeviceStatus.DISABLED
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
# act
iothub_registry_manager.update_device(device_id, primary_key, secondary_key, status, auth_method)
updated_device = iothub_registry_manager.get_device(device_id)
# verify
assert isinstance(updated_device, IoTHubDevice), 'Invalid type returned!'
assert updated_device != None, "updated_device is NULL"
assert updated_device.primaryKey == primary_key, "updated_device.primaryKey is not updated"
assert updated_device.secondaryKey == secondary_key, "updated_device.secondaryKey is not updated"
assert updated_device.authMethod == auth_method, "updated_device.authMethod is not updated"
assert updated_device.status == status, "updated_device.status is not updated"
###########################################################################
print_device_info("UpdateDevice", updated_device)
###########################################################################
# get_device_list
# prepare
req_number_of_devices = 10
# act
device_list = iothub_registry_manager.get_device_list(req_number_of_devices)
# verify
assert device_list != None, "device_list is NULL"
number_of_devices = len(device_list)
assert number_of_devices != None, "device_list is NULL"
assert number_of_devices > 0, "number_of_devices is incorrect"
###########################################################################
print ( "Number of devices : {0}".format(number_of_devices) )
###########################################################################
# get_statistics
# prepare
# act
iothub_registry_statistics = iothub_registry_manager.get_statistics()
# verify
assert iothub_registry_statistics.totalDeviceCount >= 0, "iothub_registry_statistics.totalDeviceCount is incorrect"
sum_device_count = iothub_registry_statistics.enabledDeviceCount + iothub_registry_statistics.disabledDeviceCount
assert sum_device_count >= 0, "iothub_registry_statistics.totalDeviceCount is incorrect"
###########################################################################
print ( "GetStatistics" )
print ( "Total device count : {0}".format(iothub_registry_statistics.totalDeviceCount) )
print ( "Enabled device count : {0}".format(iothub_registry_statistics.enabledDeviceCount) )
print ( "Disabled device count : {0}".format(iothub_registry_statistics.disabledDeviceCount) )
retval = 0
except Exception as e:
print ( "" )
print ("run_e2e_devicetwin() failed with exception: {0}".format(e))
retval = 1
finally:
###########################################################################
# delete_device
# prepare
# act
iothub_registry_manager.delete_device(device_id)
# verify
###########################################################################
return retval
def iothub_registrymanager_sample_run():
try:
# RegistryManager
iothub_registry_manager = IoTHubRegistryManager(CONNECTION_STRING)
# CreateDevice
primary_key = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnoo"
secondary_key = "111222333444555666777888999000aaabbbcccdddee"
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
new_device = iothub_registry_manager.create_device(
DEVICE_ID, primary_key, secondary_key, auth_method)
print_device_info("CreateDevice", new_device)
# Other authentication mechanisms:
## new_device = iothub_registry_manager.create_device(DEVICE_ID, primary_thumbprint, secondary_thumbprint, IoTHubRegistryManagerAuthMethod.X509_THUMBPRINT)
## new_device = iothub_registry_manager.create_device(DEVICE_ID, None, None, IoTHubRegistryManagerAuthMethod.X509_CERTIFICATE_AUTHORITY)
# GetDevice
iothub_device = iothub_registry_manager.get_device(DEVICE_ID)
print_device_info("GetDevice", iothub_device)
# UpdateDevice
primary_key = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
secondary_key = "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy"
status = IoTHubDeviceStatus.DISABLED
auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
iothub_registry_manager.update_device(DEVICE_ID, primary_key,
secondary_key, status,
auth_method)
updated_device = iothub_registry_manager.get_device(DEVICE_ID)
print_device_info("UpdateDevice", updated_device)
# DeleteDevice
print("DeleteDevice")
iothub_registry_manager.delete_device(DEVICE_ID)
print("")
# GetDeviceList
print("GetDeviceList")
number_of_devices = 3
dev_list = iothub_registry_manager.get_device_list(number_of_devices)
number_of_devices = len(dev_list)
print("Number of devices : {0}".format(
number_of_devices))
for device in range(0, number_of_devices):
title = "Device " + str(device)
print_device_info(title, dev_list[device])
print("")
# GetStatistics
iothub_registry_statistics = iothub_registry_manager.get_statistics()
print("GetStatistics")
print("Total device count : {0}".format(
iothub_registry_statistics.totalDeviceCount))
print("Enabled device count : {0}".format(
iothub_registry_statistics.enabledDeviceCount))
print("Disabled device count : {0}".format(
iothub_registry_statistics.disabledDeviceCount))
print("")
except IoTHubError as iothub_error:
print("Unexpected error {0}".format(iothub_error))
return
except KeyboardInterrupt:
print("IoTHubRegistryManager sample stopped")
class IoTHub:
def __init__(self, iothub_name, owner_key, suffix='.azure-devices.net'):
self.iothub_name = iothub_name
self.owner_key = owner_key
self.iothub_host = iothub_name + suffix
self.owner_connection_string = 'HostName={0};SharedAccessKeyName=iothubowner;SharedAccessKey={1}'.format(
self.iothub_host, owner_key)
self.registry_manager = IoTHubRegistryManager(
self.owner_connection_string)
self.device_twin = IoTHubDeviceTwin(self.owner_connection_string)
self.__device_clients = {}
def create_device(self, device_id, primary_key='', secondary_key=''):
return self.registry_manager.create_device(
device_id, primary_key, secondary_key,
IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY)
def delete_device(self, device_id):
return self.registry_manager.delete_device(device_id)
def disable_device(self, device_id):
self.registry_manager.update_device(
device_id, '', '', IoTHubDeviceStatus.DISABLED,
IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY)
def get_device_list(self):
return self.registry_manager.get_device_list(
1000) # NOTE: this API is marked as deprecated,
# but Python SDK doesn't seem to offer
# an alternative yet (03/25/2018).
def get_device_twin(self, device_id):
return self.device_twin.get_twin(device_id)
def __get_sas_token(self, device_id, key, policy, expiry=3600):
ttl = time() + expiry
uri = '{0}/devices/{1}'.format(self.iothub_host, device_id)
sign_key = "%s\n%d" % ((quote_plus(uri)), int(ttl))
signature = b64encode(
HMAC(b64decode(key), sign_key.encode('utf-8'), sha256).digest())
rawtoken = {'sr': uri, 'sig': signature, 'se': str(int(ttl))}
rawtoken['skn'] = policy
sas = 'SharedAccessSignature ' + urlencode(rawtoken)
return sas
# return 'HostName={0}{1};DeviceId={2};SharedAccessSignature={3}'.format(self.iothub_name, self.suffix, device_id, sas)
def update_twin(self, device_id, payload, etag='*'):
"""
Update device twin.
Unfortunately, Python IoTHub SDK does not implement optimistic concurrency, so
falling back to the REST API.
SDK equivalent:
return self.device_twin.update_twin(device_id, payload)
"""
twin_url = 'https://{0}/twins/{1}?api-version=2017-06-30'.format(
self.iothub_host, device_id)
sas_token = self.__get_sas_token(device_id, self.owner_key,
'iothubowner')
headers = {
'Authorization': sas_token,
'Content-Type': 'application/json',
'If-Match': '"{0}"'.format(etag)
}
payload_json = json.loads(payload)
keys = map(str.lower, payload_json.keys())
if 'tags' not in keys:
payload_json['tags'] = {}
if 'desiredproperties' not in keys:
payload_json['desiredProperties'] = {}
payload = json.dumps(payload_json)
r = requests.patch(twin_url, data=payload, headers=headers)
if r.status_code != HTTPStatus.OK:
raise Exception(r.text)
return r.text
def claim_device(self, client_id):
while True:
claimed_device = self.try_claim_device(client_id)
if claimed_device:
return claimed_device
sleep(random.randint(5, 10))
def try_claim_device(self, client_id):
try:
devices = self.get_device_list()
except:
return
random.shuffle(devices)
for device in devices:
current_time = datetime.datetime.utcnow().replace(tzinfo=None)
last_activity_time = dateutil.parser.parse(
device.lastActivityTime).replace(tzinfo=None)
# it seems that sometimes devices remain in a CONNECTED state long after the connection is lost,
# so claiming CONNECTED devices that have been inactive for at least 10 minutes
if device.connectionState == IoTHubDeviceConnectionState.CONNECTED and (
current_time - last_activity_time).total_seconds() < 600:
continue
if device.status == IoTHubDeviceStatus.DISABLED:
continue
# attempt to acquire lock using device twin's optimistic concurrency
twin_data = self.get_device_twin(device.deviceId)
twin_data_json = json.loads(twin_data)
random.randint(5, 10)
etag = twin_data_json['etag']
twin_tags = None
if 'tags' not in twin_data_json:
twin_tags = {}
else:
twin_tags = twin_data_json['tags']
if 'simulated' not in twin_tags or not twin_tags['simulated']:
continue
if 'simulator' not in twin_tags:
continue
if '_claim' in twin_tags:
simulator_data = twin_tags['_claim']
if 'lastClaimed' in simulator_data:
last_claimed = dateutil.parser.parse(
simulator_data['lastClaimed']).replace(tzinfo=None)
if (current_time - last_claimed).total_seconds() < 600:
continue
twin_tags['_claim'] = {
'clientId': client_id,
'lastClaimed': current_time.isoformat()
}
updated_properties = {'tags': twin_tags}
try:
updated_twin_data = self.update_twin(
device.deviceId, json.dumps(updated_properties), etag)
logging.log(logging.INFO, 'Claimed device %s.',
device.deviceId)
return device, updated_twin_data
except:
continue