async def result_from_register(registration_id, device_cert_file, device_key_file): x509 = X509(cert_file=device_cert_file, key_file=device_key_file, pass_phrase=device_password) provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=PROVISIONING_HOST, registration_id=registration_id, id_scope=ID_SCOPE, x509=x509, ) return await provisioning_device_client.register()
async def result_from_register(registration_id, device_cert_file, device_key_file, protocol): x509 = X509(cert_file=device_cert_file, key_file=device_key_file, pass_phrase=device_password) protocol_boolean_mapping = {"mqtt": False, "mqttws": True} provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=PROVISIONING_HOST, registration_id=registration_id, id_scope=ID_SCOPE, x509=x509, websockets=protocol_boolean_mapping[protocol], ) return await provisioning_device_client.register()
async def register_device(): x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=provisioning_host, registration_id=registration_id, id_scope=id_scope, x509=x509, ) await provisioning_device_client.register()
async def main(): x509 = X509( cert_file=os.getenv("X509_CERT_FILE"), key_file=os.getenv("X509_KEY_FILE"), pass_phrase=os.getenv("PASS_PHRASE"), ) provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=provisioning_host, registration_id=registration_id, id_scope=id_scope, x509=x509, ) registration_result = await provisioning_device_client.register() print("The complete registration result is") print(registration_result.registration_state) if registration_result.status == "assigned": print("Will send telemetry from the provisioned device") device_client = IoTHubDeviceClient.create_from_x509_certificate( x509=x509, hostname=registration_result.registration_state.assigned_hub, device_id=registration_result.registration_state.device_id, ) # Connect the client. await device_client.connect() async def send_test_message(i): print("sending message #" + str(i)) msg = Message("test wind speed " + str(i)) msg.message_id = uuid.uuid4() msg.correlation_id = "correlation-1234" msg.custom_properties["count"] = i msg.custom_properties["tornado-warning"] = "yes" await device_client.send_message(msg) print("done sending message #" + str(i)) # send `messages_to_send` messages in parallel await asyncio.gather(*[send_test_message(i) for i in range(1, messages_to_send + 1)]) # finally, disconnect await device_client.disconnect() else: print("Can not send telemetry from the provisioned device")
async def auth_and_connect(self): if self._isConnected: return model_id = self._modelDev.model_id() auth_conf = self._modelConfig.auth_props() if auth_conf.get(ModelConfigBase.IOTHUB_DEVICE_DPS_AUTH_MODE): print ("auth.mode", auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_AUTH_MODE] ) if self._modelConfig.is_x509_mode(): x509 = X509( cert_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_CERT], key_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_KEY], pass_phrase=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_PASS], ) provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ENDPOINT], registration_id=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_ID], id_scope=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ID_SCOPE], x509=x509, ) else: provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key( provisioning_host=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ENDPOINT], registration_id=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_ID], id_scope=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_ID_SCOPE], symmetric_key=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_KEY] ) provisioning_device_client.provisioning_payload = { "modelId": model_id } try: registration_result = await provisioning_device_client.register() if registration_result.status != "assigned": print("Could not provision device.") return ErrorCode.AuthenticationFailed else: print("Device was assigned") except: print("Connection error.") return ErrorCode.ConnectionFailed registration_state = registration_result.registration_state print(registration_state.assigned_hub) print(registration_state.device_id) if self._modelConfig.is_x509_mode(): x509 = X509( cert_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_CERT], key_file=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_KEY], pass_phrase=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_X509_PASS], ) device_client = IoTHubDeviceClient.create_from_x509_certificate( x509=x509, hostname=registration_state.assigned_hub, device_id=registration_state.device_id, product_info=model_id, connection_retry=False ) else: device_client = IoTHubDeviceClient.create_from_symmetric_key( symmetric_key=auth_conf[ModelConfigBase.IOTHUB_DEVICE_DPS_DEVICE_KEY], hostname=registration_state.assigned_hub, device_id=registration_state.device_id, product_info=model_id, connection_retry=False ) await device_client.connect() twin = await device_client.get_twin() if 'desired' in twin: desiredProps = twin['desired'] del (desiredProps)['$version'] for name in iter(desiredProps): self._modelDev.set_prop(name, desiredProps[name]) del (twin['reported'])['$version'] props = self._modelDev.props() if props != twin['reported']: await device_client.patch_twin_reported_properties(props) device_client.on_method_request_received = self._method_request_handler device_client.on_twin_desired_properties_patch_received = self._twin_patch_handler device_client.on__message_received = self._message_received_handler self._clientHandle = device_client self._isConnected = True return ErrorCode.Success
async def main(): global device_client global device_symmetric_key random.seed() dps_registered = False connected = False connection_retry_count = 1 x509 = None while (not connected): # and (connection_retry_count < 3): if use_cached_credentials and os.path.exists('dpsCache.json'): dps_cache = read_dps_cache_from_file() if dps_cache[2] == device_id: dps_registered = True else: os.remove('dpsCache.json') continue else: if use_x509: # register the device using the X509 certificate current_path = os.path.dirname(os.path.abspath(__file__)) x509 = X509(cert_file=os.path.join(current_path, x509_public_cert_file), key_file=os.path.join(current_path, x509_private_cert_file), pass_phrase=x509_pass_phrase) provisioning_device_client = ProvisioningDeviceClient.create_from_x509_certificate( provisioning_host=provisioning_host, registration_id=device_id, id_scope=id_scope, x509=x509, websockets=use_websockets) else: # use symmetric key if use_group_symmetric_key: # use group symmetric key to generate a device symmetric key device_symmetric_key = derive_device_key( device_id, group_symmetric_key) provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key( provisioning_host=provisioning_host, registration_id=device_id, id_scope=id_scope, symmetric_key=device_symmetric_key, websockets=use_websockets) provisioning_device_client.provisioning_payload = '{"iotcModelId":"%s"}' % ( model_identity) registration_result = None try: registration_result = await provisioning_device_client.register( ) except exceptions.CredentialError: print("Credential Error") except exceptions.ConnectionFailedError: print("Connection Failed Error") except exceptions.ConnectionDroppedError: # error if the key is wrong print("Connection Dropped Error") except exceptions.ClientError as inst: # error if the device is blocked print("ClientError") except Exception: print("Unknown Exception") dps_cache = (device_symmetric_key, registration_result.registration_state.assigned_hub, registration_result.registration_state.device_id) if use_cached_credentials: write_dps_cache_to_file(dps_cache) print("The complete registration result is %s" % (registration_result.registration_state)) if registration_result.status == "assigned": dps_registered = True if dps_registered: if use_x509: # create device client on IoT Hub using the X509 certificate device_client = IoTHubDeviceClient.create_from_x509_certificate( x509=x509, hostname=registration_result.registration_state. assigned_hub, device_id=registration_result.registration_state.device_id, ) else: # create device client on IoT Hub using a device symmetric key device_client = IoTHubDeviceClient.create_from_symmetric_key( symmetric_key=dps_cache[0], hostname=dps_cache[1], device_id=dps_cache[2], websockets=use_websockets) # connect to IoT Hub try: await device_client.connect() connected = True except: print("Connection failed, retry %d of 3" % (connection_retry_count)) if os.path.exists('dpsCache.json'): os.remove('dpsCache.json') dps_registered = False connection_retry_count = connection_retry_count + 1 # add desired property listener twin_listener = asyncio.create_task(twin_patch_handler(device_client)) # add direct method listener direct_method_listener = asyncio.create_task( direct_method_handler(device_client)) # add C2D listener c2d_listener = asyncio.create_task(message_listener(device_client)) # add tasks to send telemetry (every 5 seconds) and reported properties (every 20, 25, 30 seconds respectively) telemetry_loop = asyncio.create_task(send_telemetry(device_client, 5)) reported_loop1 = asyncio.create_task( send_reportedProperty(device_client, "text", "string", 20)) reported_loop2 = asyncio.create_task( send_reportedProperty(device_client, "boolean", "bool", 25)) reported_loop3 = asyncio.create_task( send_reportedProperty(device_client, "number", "number", 30)) keyboard_loop = asyncio.get_running_loop().run_in_executor( None, keyboard_monitor, [twin_listener, direct_method_listener, c2d_listener]) #awit the tasks ending before exiting try: await asyncio.gather(twin_listener, c2d_listener, direct_method_listener, telemetry_loop, reported_loop1, reported_loop2, reported_loop3, keyboard_loop) except asyncio.CancelledError: pass # ignore the cancel actions on twin_listener and direct_method_listener # finally, disconnect print("Disconnecting from IoT Hub") await device_client.disconnect()