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()