class IotHubManager(object):
def __init__(self, protocol=IOT_HUB_PROTOCOL):
print("Creating IoT Hub manager")
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
# set the time until a message times out
self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)
def subscribe_to_events(self):
print("Subscribing to method calls")
self.client.set_module_method_callback(method_callback, 0)
print("Subscribing to module twin updates")
self.client.set_module_twin_callback(module_twin_callback,
MODULE_TWIN_UPDATE_CONTEXT)
# sends a messager to the "ToUpstream" queue to be sent to hub
def send_message_to_upstream(self, message):
try:
message = IoTHubMessage(message)
self.client.send_event_async(TO_UPSTREAM_MESSAGE_QUEUE_NAME,
message, send_confirmation_callback,
0)
# logging.info("finished sending message...")
except Exception as ex:
print("Exception in send_message_to_upstream: %s" % ex)
pass
class HubManager(object):
def __init__(self, protocol=IoTHubTransportProvider.MQTT):
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
# sets the callback when a message arrives on "input1" queue. Messages sent to other inputs or to the default will be silently discarded.
self.client.set_message_callback("input1", blink_callback, self)
self.client.set_module_method_callback(module_method_callback, None)
class HubManager(object):
def __init__(self, protocol=IoTHubTransportProvider.MQTT):
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
# set the time until a message times out
self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)
self.client.set_module_twin_callback(module_twin_callback, self)
self.client.set_module_method_callback(method_callback, 0)
class HubManager(object):
def __init__(self):
# Defines settings of the IoT SDK
protocol = IoTHubTransportProvider.MQTT
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
self.client.set_option("logtrace", 1) #enables MQTT logging
self.client.set_option("messageTimeout", 10000)
# sets the callback when a message arrives on "input1" queue. Messages sent to
# other inputs or to the default will be silently discarded.
self.client.set_message_callback("input1", receive_message_callback,
self)
print("Module is now waiting for messages in the input1 queue.")
self.client.set_module_method_callback(method_callback, self)
class HubManager(object):
def __init__(self, protocol=IoTHubTransportProvider.MQTT):
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
# set the time until a message times out
self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)
# sets the callback when a message arrives on "input1" queue. Messages sent to
# other inputs or to the default will be silently discarded.
self.client.set_message_callback("input1", receive_message_callback,
self)
print('subscribing to method calls')
# Register the callback with the client
self.client.set_module_method_callback(method_callback, 0)
# Forwards the message received onto the next stage in the process.
def forward_event_to_output(self, outputQueueName, event, send_context):
self.client.send_event_async(outputQueueName, event,
send_confirmation_callback, send_context)
class HubManager(object):
def __init__(self, protocol=IoTHubTransportProvider.MQTT):
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
# set the time until a message times out
self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)
# sets the callback when a message arrives on "input1" queue. Messages sent to
# other inputs or to the default will be silently discarded.
self.client.set_message_callback("input1", receive_message_callback,
self)
# items added to show the complete functionality
self.client.set_module_twin_callback(module_twin_callback, self)
self.client.set_module_method_callback(module_method_callback, self)
# updating the Module TWIN with a started time
reported_state = "{\"started\":\"" + str(
datetime.datetime.now()) + "\"}"
self.client.send_reported_state(reported_state, len(reported_state),
send_reported_state_callback, self)
def updateReportedTWIN(self):
reported_state = {}
reported_state["RESTTargetURL"] = RESTTargetURL
reported_state["RESTTargetLocation"] = RESTTargetLocation
reported_state["POLINGInterval"] = POLINGInterval
reported_statestr = json.dumps(reported_state)
self.client.send_reported_state(reported_statestr,
len(reported_statestr),
send_reported_state_callback, self)
# Forwards the message received onto the next stage in the process.
def forward_event_to_output(self, outputQueueName, event, send_context):
self.client.send_event_async(outputQueueName, event,
send_confirmation_callback, send_context)
def run_e2e_device_client(iothub_service_client_messaging,
iothub_device_method, iothub_device_twin, device_id,
device_or_module_connection_string, protocol,
authMethod, testing_modules):
global IOTHUB_E2E_X509_CERT
global IOTHUB_E2E_X509_THUMBPRINT
global IOTHUB_E2E_X509_PRIVATE_KEY
global CERTIFICATES
global MESSAGING_CONTEXT
###########################################################################
# IoTHubClient
# prepare
# act
if testing_modules == True:
device_client = IoTHubModuleClient(device_or_module_connection_string,
protocol)
assert isinstance(device_client,
IoTHubModuleClient), 'Error: Invalid type returned!'
else:
device_client = IoTHubDeviceClient(device_or_module_connection_string,
protocol)
assert isinstance(device_client,
IoTHubDeviceClient), 'Error: Invalid type returned!'
# verify
assert device_client != None, "Error: device_client is NULL"
###########################################################################
###########################################################################
# set_option
# prepare
# act
device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT)
if authMethod == IoTHubRegistryManagerAuthMethod.X509_THUMBPRINT:
device_client.set_option("x509certificate", IOTHUB_E2E_X509_CERT)
device_client.set_option("x509privatekey", IOTHUB_E2E_X509_PRIVATE_KEY)
if device_client.protocol == IoTHubTransportProvider.HTTP:
device_client.set_option("timeout", HTTP_TIMEOUT)
device_client.set_option("MinimumPollingTime",
HTTP_MINIMUM_POLLING_TIME)
device_client.set_option("TrustedCerts", CERTIFICATES)
device_client.set_option("logtrace", True)
# verify
###########################################################################
if testing_modules == False: ## Modules do not currently support set_message_callback outside context of Edge inputs/outputs
###########################################################################
# set_message_callback
# prepare
# act
device_client.set_message_callback(receive_message_callback,
MESSAGING_CONTEXT)
###########################################################################
###########################################################################
# set_connection_status_callback
# prepare
# act
device_client.set_connection_status_callback(connection_status_callback,
CONNECTION_STATUS_CONTEXT)
###########################################################################
# verify
###########################################################################
if protocol == IoTHubTransportProvider.AMQP \
or protocol == IoTHubTransportProvider.AMQP_WS \
or protocol == IoTHubTransportProvider.MQTT \
or protocol == IoTHubTransportProvider.MQTT_WS:
###########################################################################
# set_device_twin_callback
# prepare
# act
if testing_modules == True:
device_client.set_module_twin_callback(device_twin_callback,
MESSAGING_CONTEXT)
else:
device_client.set_device_twin_callback(device_twin_callback,
MESSAGING_CONTEXT)
# verify
###########################################################################
###########################################################################
# set_device_method_callback
# prepare
# act
if testing_modules == True:
device_client.set_module_method_callback(device_method_callback,
MESSAGING_CONTEXT)
else:
device_client.set_device_method_callback(device_method_callback,
MESSAGING_CONTEXT)
# verify
###########################################################################
###########################################################################
# update device twin
# prepare
global TWIN_CALLBACK_EVENT
global TWIN_CALLBACK_COUNTER
TWIN_CALLBACK_EVENT.clear()
TWIN_CALLBACK_COUNTER = 0
# act
sc_update_twin(iothub_device_twin, device_id, testing_modules)
TWIN_CALLBACK_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert TWIN_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called"
###########################################################################
###########################################################################
# call device method
# prepare
global DEVICE_METHOD_EVENT
global DEVICE_METHOD_CALLBACK_COUNTER
DEVICE_METHOD_EVENT.clear()
DEVICE_METHOD_CALLBACK_COUNTER = 0
method_name = "E2EMethodName"
payload_json = "{\"method_number\":\"42\"}"
# act
sc_invoke_device_method(iothub_device_method, device_id, method_name,
payload_json, testing_modules)
DEVICE_METHOD_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert DEVICE_METHOD_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called"
###########################################################################
###########################################################################
# send_reported_state
# prepare
global REPORTED_STATE_EVENT
global REPORTED_STATE_CALLBACK_COUNTER
reported_state = "{\"newState\":\"standBy\"}"
REPORTED_STATE_EVENT.clear()
REPORTED_STATE_CALLBACK_COUNTER = 0
# act
device_client.send_reported_state(reported_state, len(reported_state),
send_reported_state_callback,
REPORTED_STATE_CONTEXT)
REPORTED_STATE_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert REPORTED_STATE_CALLBACK_COUNTER > 0, "Error: send_reported_state_callback has not been called"
###########################################################################
###########################################################################
# set_retry_policy
# get_retry_policy
# prepare
# act
retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL
retryInterval = 100
device_client.set_retry_policy(retryPolicy, retryInterval)
print("SetRetryPolicy to: retryPolicy = %d" % retryPolicy)
print("SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval)
# verify
retryPolicyReturn = device_client.get_retry_policy()
assert retryPolicyReturn.retryPolicy == IoTHubClientRetryPolicy.RETRY_INTERVAL, "Error: set_retry_policy/get_retry_policy failed"
assert retryPolicyReturn.retryTimeoutLimitInSeconds == 100, "Error: set_retry_policy/get_retry_policy failed"
print("GetRetryPolicy returned: retryPolicy = %d" %
retryPolicyReturn.retryPolicy)
print("GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" %
retryPolicyReturn.retryTimeoutLimitInSeconds)
if testing_modules == False: ## Modules do not currently support set_message_callback outside context of Edge inputs/outputs
###########################################################################
# send_event_async
# prepare
global MESSAGING_MESSAGE
global MESSAGE_RECEIVE_EVENT
global MESSAGE_RECEIVE_CALLBACK_COUNTER
MESSAGING_MESSAGE = ''.join(
[random.choice(string.ascii_letters) for n in range(12)])
message = IoTHubMessage(bytearray(MESSAGING_MESSAGE, 'utf8'))
MESSAGE_RECEIVE_EVENT.clear()
MESSAGE_RECEIVE_CALLBACK_COUNTER = 0
# act
sc_send_message(iothub_service_client_messaging, device_id, message,
testing_modules)
MESSAGE_RECEIVE_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert MESSAGE_RECEIVE_CALLBACK_COUNTER > 0, "Error: message has not been received"
###########################################################################
###########################################################################
# get_send_status
# prepare
status_counter = 0
status = -1
# act
while status_counter < 1:
status = device_client.get_send_status()
print("Send status: {0}".format(status))
# verify
assert status == 0, "get_send_status reported status is not IDLE"
status_counter += 1
###########################################################################
if protocol != IoTHubTransportProvider.AMQP \
and protocol != IoTHubTransportProvider.AMQP_WS:
###########################################################################
# get_last_message_receive_time
# prepare
last_receive_time = -1
# act
last_receive_time = device_client.get_last_message_receive_time()
# verify
assert last_receive_time > 0, "Error: get_last_message_receive_time failed"
###########################################################################
if testing_modules == False: ## Modules do not currently support uploadToBlob
###########################################################################
# upload_blob_async
# prepare
global BLOB_UPLOAD_CONTEXT
global BLOB_UPLOAD_EVENT
global BLOB_UPLOAD_CALLBACK_COUNTER
destination_file_name = ''.join(
[random.choice(string.ascii_letters) for n in range(12)])
source = "Blob content for file upload test!"
size = 34
BLOB_UPLOAD_EVENT.clear()
BLOB_UPLOAD_CALLBACK_COUNTER = 0
# act
device_client.upload_blob_async(destination_file_name, source, size,
blob_upload_conf_callback,
BLOB_UPLOAD_CONTEXT)
BLOB_UPLOAD_EVENT.wait(CALLBACK_TIMEOUT)
# verify
assert BLOB_UPLOAD_CALLBACK_COUNTER > 0, "Error: blob_upload_conf_callback callback has not been called"
class IotHubManager(object):
def __init__(self, protocol, camera_client: CameraClient, properties: Properties):
print("Creating IoT Hub manager")
self.client_protocol = protocol
self.client = IoTHubModuleClient()
self.client.create_from_environment(protocol)
self.camera_client = camera_client
self.properties = properties
# set the time until a message times out
self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)
def subscribe_to_events(self):
print("Subscribing to method calls")
self.client.set_module_method_callback(self.__method_callback_handler, 0)
print("Subscribing to module twin updates")
self.client.set_module_twin_callback(
self.__module_twin_callback, MODULE_TWIN_UPDATE_CONTEXT)
# sends a messager to the "ToUpstream" queue to be sent to hub
def send_message_to_upstream(self, message):
try:
message = IoTHubMessage(message)
self.client.send_event_async(
TO_UPSTREAM_MESSAGE_QUEUE_NAME,
message,
self.__send_confirmation_callback,
0)
# logging.info("finished sending message...")
except Exception as ex:
print("Exception in send_message_to_upstream: %s" % ex)
pass
# Callback received when the message that we're forwarding is processed.
def __send_confirmation_callback(self, message, result, user_context):
global send_callbacks
print("Confirmation[%d] received for message with result = %s" % (
user_context, result))
map_properties = message.properties()
key_value_pair = map_properties.get_internals()
print("\tProperties: %s" % key_value_pair)
send_callbacks += 1
print("\tTotal calls confirmed: %d" % send_callbacks)
def __method_callback_handler(self, method_name, payload, user_context):
"""
Private method to handle the callbacks from the IoT Hub by calling the
callback matching `method_name`
"""
retval = {
TURN_CAMERA_ON_METHOD_NAME:
lambda payload, user_context: self.__turn_camera_on_callback(
payload, user_context),
TURN_CAMERA_OFF_METHOD_NAME:
lambda payload, user_context: self.__turn_camera_off_callback(
payload, user_context)
}[method_name](payload, user_context)
return retval
def __turn_camera_on_callback(self, payload, user_context):
retval = DeviceMethodReturnValue()
try:
self.camera_client.set_preview_state(SETTING_ON)
# TODO: restart analytics
retval.status = 200
retval.response = "{\"Response\":\"Successfully started camera\"}"
return retval
except Exception:
retval.status = 500
retval.response = "{\"Response\":\"Failed to start camera\"}"
return retval
def __turn_camera_off_callback(self, payload, user_context):
retval = DeviceMethodReturnValue()
try:
self.camera_client.set_overlay_state(SETTING_OFF)
self.camera_client.set_analytics_state(SETTING_OFF)
self.camera_client.set_preview_state(SETTING_OFF)
retval.status = 200
retval.response = "{\"Response\":\"Successfully stopped camera\"}"
return retval
except Exception:
retval.status = 500
retval.response = "{\"Response\":\"Failed to stop camera\"}"
return retval
def __module_twin_callback(self, update_state, payload, user_context):
print("Received twin callback")
self.properties.handle_twin_update(payload)
self.__update_model_and_config()
def __update_model_and_config(self):
model_props = self.properties.model_properties
camera_props = self.properties.camera_properties
if not self.camera_client:
print("Handle updates aborting")
print("\tcamera_client is %s" % self.camera_client)
return
try:
is_model_changed = model_props.update_inference_model()
camera_props.configure_camera_client(self.camera_client, is_model_changed)
self.properties.report_properties_to_hub(self)
except Exception as ex:
log_unknown_exception(
"Error raised while handling update callback: %s" % ex,
self)
raise ex
