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" )
Beispiel #2
0
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
Beispiel #3
0
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
Beispiel #4
0
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
Beispiel #5
0
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
Beispiel #10
0
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