class HubManager(object): def __init__(self, messageTimeout, protocol, verbose): ''' Communicate with the Edge Hub :param int messageTimeout: the maximum time in milliseconds until a message times out. The timeout period starts at IoTHubClient.send_event_async. By default, messages do not expire. :param IoTHubTransportProvider protocol: Choose HTTP, AMQP or MQTT as transport protocol. Currently only MQTT is supported. :param bool verbose: set to true to get detailed logs on messages ''' self.TWIN_CONTEXT = 0 self.messageTimeout = messageTimeout self.client_protocol = protocol self.client = IoTHubModuleClient() self.client.create_from_environment(protocol) self.client.set_option("messageTimeout", self.messageTimeout) self.client.set_option("product_info", "edge-camera-capture") self.client.set_module_twin_callback(module_twin_callback, 0) if verbose: self.client.set_option("logtrace", 1) # enables MQTT logging def send_event_to_output(self, outputQueueName, event, send_context): self.client.send_event_async(outputQueueName, event, send_confirmation_callback, send_context) def send_reported_property_update(self, propertyName, propertyValue, send_context): reported_state = "{\"" + propertyName + "\":\"" + propertyValue + "\"}" self.client.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, send_context) print("Reported property updated: " + str(reported_state))
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) # register for TWIN updates self.client.set_module_twin_callback(module_twin_callback, self) def updateReportedTWIN(self): reported_state = {} reported_state["POLLINGfrequency"] = POLLINGfrequency reported_state["POLLINGHost"] = POLLINGHost 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)
class HubManager(object): TIMER_COUNT = 2 TWIN_CONTEXT = 0 SEND_REPORTED_STATE_CONTEXT = 0 def __init__(self, protocol=IoTHubTransportProvider.MQTT): self.client_protocol = protocol self.client = IoTHubModuleClient() self.client.create_from_environment(protocol) #self.iotedgemodule = iotedgemodules() # 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) # 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 iothub_client_sample_run(self, message): try: #client = self.iothub_client_init() if self.client.protocol == IoTHubTransportProvider.MQTT: print("Sending data as reported property...") reported_state = "{\"rtsp_addr\":\"" + message + "\"}" self.client.send_reported_state( reported_state, len(reported_state), send_reported_state_callback, self.SEND_REPORTED_STATE_CONTEXT) status_counter = 0 while status_counter <= self.TIMER_COUNT: status = self.client.get_send_status() time.sleep(2) status_counter += 1 except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped") def SendMsgToCloud(self, msg): try: #print("sending message...") message = IoTHubMessage(msg) self.client.send_event_async("output1", message, send_confirmation_callback, 0) #print("finished sending message...") except Exception: print("Exception in SendMsgToCloud") pass
class HubManager(object): def __init__(self, messageTimeout, protocol, verbose, videoCapture): # Communicate with the Edge Hub self.messageTimeout = messageTimeout self.client_protocol = protocol self.client = IoTHubModuleClient() self.client.create_from_environment(protocol) self.client.set_option("messageTimeout", self.messageTimeout) self.client.set_option("product_info", "iotedge-jetson-nano-yolov3") self.videoCapture = videoCapture if verbose: self.client.set_option("logtrace", 1) #enables MQTT logging self.client.set_module_twin_callback(module_twin_callback, self) def send_reported_state(self, reported_state, size, user_context): self.client.send_reported_state(reported_state, size, send_reported_state_callback, user_context) def send_event_to_output(self, outputQueueName, event, send_context): self.client.send_event_async(outputQueueName, event, send_confirmation_callback, send_context) def module_twin_send_reported(self): jsonTemplate = "{\"ConfidenceLevel\": \"%s\",\"VerboseMode\": %d,\"Inference\": %d, \"VideoSource\":\"%s\"}" videoCapture = hubManager.videoCapture strUrl = videoCapture.videoPath jsonData = jsonTemplate % (str( videoCapture.confidenceLevel), videoCapture.verbose, videoCapture.runInference, strUrl) logging.info('device_twin_send_reported()') logging.info(' - payload : {}'.format(json.dumps(jsonData, indent=4))) hubManager.send_reported_state(jsonData, len(jsonData), 1002)
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)
class HubManager(object): def __init__(self, protocol=IoTHubTransportProvider.MQTT): # init Instance Attributes self.MESSAGE_DELAY = 0 # init IoTHubModuleClient 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) # send a message to the next stage in the process. def send_async(self, outputQueueName, event, send_context): self.client.send_event_async(outputQueueName, event, send_confirmation_callback, send_context) #update modules twin reported properties def send_reported_state(self, reported_state, size, user_context): self.client.send_reported_state(reported_state, size, send_reported_state_callback, user_context)
class HubManager(object): def __init__(self, messageTimeout, protocol, verbose): # Communicate with the Edge Hub self.messageTimeout = messageTimeout self.client_protocol = protocol self.client = IoTHubModuleClient() self.client.create_from_environment(protocol) self.client.set_option("messageTimeout", self.messageTimeout) self.client.set_option("product_info", "edge-yolo-capture") if verbose: self.client.set_option("logtrace", 1) #enables MQTT logging self.client.set_module_twin_callback(device_twin_callback, None) def send_reported_state(self, reported_state, size, user_context): self.client.send_reported_state(reported_state, size, send_reported_state_callback, user_context) def send_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): TIMER_COUNT = 2 def __init__(self, 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) self.client.set_module_twin_callback(self.module_twin_callback, self) self.setRestartCamera = False cam_type = "video_file" cam_source = "/sample_video/video.mp4" self.model_dst_folder = "./default_model" self.model_url = None self.ret_flag = None def send_message_to_output(self, message, output_name, last_sent_time=time.time()): try: #delaying message send to IotHub as we have 400+ msg per sec if we send all up we will exhaust IotHub limit #if(time.time() - last_sent_time <= (60/msg_per_minute)): # return last_sent_time message = IoTHubMessage(message) self.client.send_event_async(output_name, message, self.__send_confirmation_callback, 0) print('message sent') last_sent_time = time.time() return last_sent_time # logging.info("finished sending message...") except Exception as ex: print("Exception in send_message_to_output: %s" % ex) pass # sends a messager to the "ToUpstream" queue to be sent to hub def send_message_to_upstream(self, message, last_sent_time=time.time()): try: #delaying message send to IotHub as we have 400+ msg per sec if we send all up we will exhaust IotHub limit if (time.time() - last_sent_time <= (60 / msg_per_minute)): return last_sent_time message = IoTHubMessage(message) self.client.send_event_async(TO_UPSTREAM_MESSAGE_QUEUE_NAME, message, self.__send_confirmation_callback, 0) last_sent_time = time.time() return last_sent_time # 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 send_reported_state_callback(self, status_code, user_context): print("") print("Confirmation for reported state called with:") print(" status_code: %d" % status_code) def send_property(self, prop): try: if self.client.protocol == IoTHubTransportProvider.MQTT: self.client.send_reported_state( prop, len(prop), self.send_reported_state_callback, prop) except Exception as ex: print("Exception in send_property: %s" % ex) def module_twin_callback(self, update_state, payload, user_context): global inference_files_zip_url global msg_per_minute global object_of_interest print("") print("Twin callback called with:") print(" updateStatus: %s" % update_state) print(" payload: %s" % payload) data = json.loads(payload) self.setRestartCamera = False if "desired" in data and "inference_files_zip_url" in data["desired"]: self.model_dst_folder = "default_model" inference_files_zip_url = data["desired"][ "inference_files_zip_url"] if inference_files_zip_url: print( "\n Setting value to %s from :: data[\"desired\"][\"all_inference_files_zip\"]" % inference_files_zip_url) self.setRestartCamera = get_file_zip(inference_files_zip_url, self.model_dst_folder) self.model_url = inference_files_zip_url else: print(inference_files_zip_url) self.model_url = None if "inference_files_zip_url" in data: self.model_dst_folder = "default_model" inference_files_zip_url = data["inference_files_zip_url"] if inference_files_zip_url: print( "\n Setting value to %s from :: data[\"all_inference_files_zip\"]" % inference_files_zip_url) self.ret_flag = get_file_zip(inference_files_zip_url, self.model_dst_folder) #self.setRestartCamera = True self.model_url = inference_files_zip_url else: print(inference_files_zip_url) self.model_url = None if "desired" in data and "cam_type" in data["desired"]: cam_type = data["desired"]["cam_type"] self.cam_type = str(cam_type) print("Setting value to %s from :: data[desired][cam_type]" % cam_type) self.ret_flag = True elif "cam_type" in data: cam_type = data["cam_type"] self.cam_type = str(cam_type) print("Setting value to %s from :: data[cam_type]" % cam_type) self.ret_flag = True if "desired" in data and "cam_source" in data["desired"]: cam_source = data["desired"]["cam_source"] self.cam_source = str(cam_source) print("Setting value to %s from :: data[desired][cam_source]" % cam_source) self.ret_flag = True elif "cam_source" in data: cam_source = data["cam_source"] self.cam_source = str(cam_source) print("Setting value to %s from :: data[cam_source]" % cam_source) self.ret_flag = True if self.cam_source: if self.cam_type == "video_file": print("self.cam_source %s file" % self.cam_source) dst_folder = "sample_video" print( "\n Download and unzip video file to sample dir from %s" % self.cam_source) self.ret_flag = get_file_zip(self.cam_source, dst_folder) #ToDo readfilename and add to dst_folder self.cam_source = "/sample_video/video.mp4" #self.setRestartCamera = True else: print(self.cam_source) if "desired" in data and "object_of_interest" in data["desired"]: object_of_interest = data["desired"]["object_of_interest"] print("Setting value to %s from :: data[\"object_of_interest\"]" % object_of_interest) if "object_of_interest" in data: object_of_interest = data["object_of_interest"] print("Setting value to %s from :: data[\"object_of_interest\"]" % object_of_interest) if "desired" in data and "msg_per_minute" in data["desired"]: msg_per_minute = data["desired"]["msg_per_minute"] print("Setting value to %s from :: data[\"msg_per_minute\"]" % msg_per_minute) if "msg_per_minute" in data: msg_per_minute = data["msg_per_minute"] print("Setting value to %s from :: data[\"msg_per_minute\"]" % msg_per_minute) if self.ret_flag: try: print("setting restart inferense to True") self.setRestartCamera = True logger.info("Restarting inferencing") except Exception as e: logger.info("Got an issue during cam ON off after twin update") logger.exception(e) raise
class HubManager(object): TIMER_COUNT = 2 TWIN_CONTEXT = 0 SEND_REPORTED_STATE_CONTEXT = 0 def __init__(self, camera_handle, protocol=IoTHubTransportProvider.MQTT): self.client_protocol = protocol self.client = IoTHubModuleClient() self.client.create_from_environment(protocol) self.iot_camera_handle = camera_handle # 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) self.client.set_module_twin_callback(self.module_twin_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 iothub_client_sample_run(self, message): try: if self.client.protocol == IoTHubTransportProvider.MQTT: print("Sending data as reported property...") reported_state = "{\"rtsp_addr\":\"" + message + "\"}" self.client.send_reported_state( reported_state, len(reported_state), send_reported_state_callback, self.SEND_REPORTED_STATE_CONTEXT) status_counter = 0 while status_counter <= self.TIMER_COUNT: status = self.client.get_send_status() time.sleep(2) status_counter += 1 except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped") def SendMsgToCloud(self, msg): try: #logging.info("sending message...") message = IoTHubMessage(msg) self.client.send_event_async("output1", message, send_confirmation_callback, 0) logging.info("finished sending message...") except Exception: print("Exception in SendMsgToCloud") pass def module_twin_callback(self, update_state, payload, user_context): global inference_files_zip_url global model_url global label_url global config_url global msg_per_minute global wait_for_minutes global object_of_interest print("") print("Twin callback called with:") print(" updateStatus: %s" % update_state) print(" payload: %s" % payload) data = json.loads(payload) setRestartCamera = False if "desired" in data and "inference_files_zip_url" in data["desired"]: dst_folder = "twin_provided_model" inference_files_zip_url = data["desired"][ "inference_files_zip_url"] if inference_files_zip_url: print( "Setting value to %s from :: data[\"desired\"][\"all_inference_files_zip\"]" % inference_files_zip_url) setRestartCamera = get_file_zip(inference_files_zip_url, dst_folder) else: print(inference_files_zip_url) if "inference_files_zip_url" in data: dst_folder = "twin_provided_model" inference_files_zip_url = data["inference_files_zip_url"] if inference_files_zip_url: print( "Setting value to %s from :: data[\"all_inference_files_zip\"]" % inference_files_zip_url) setRestartCamera = get_file_zip(inference_files_zip_url, dst_folder) else: print(inference_files_zip_url) if "desired" in data and "msg_per_minute" in data["desired"]: msg_per_minute = data["desired"]["msg_per_minute"] msg_per_minute = 60 / int(msg_per_minute) print("Setting value to %s from :: data[\"msg_per_minute\"]" % msg_per_minute) if "msg_per_minute" in data: msg_per_minute = data["msg_per_minute"] wait_for_minutes = int(60 / int(msg_per_minute)) print("Setting value to %s from :: data[\"msg_per_minute\"]" % msg_per_minute) if "desired" in data and "object_of_interest" in data["desired"]: object_of_interest = data["desired"]["object_of_interest"] print("Setting value to %s from :: data[\"object_of_interest\"]" % object_of_interest) if "object_of_interest" in data: msg_per_minute = data["object_of_interest"] print("Setting value to %s from :: data[\"object_of_interest\"]" % object_of_interest) if setRestartCamera: # try: logger.info("Restarting VAM to apply new model config") self.restartInference(self.iot_camera_handle) except Exception as e: logger.info("Got an issue during vam ON off after twin update") logger.exception(e) raise def restartInference(self, camera_client): try: logger.debug("Restarting VAM to apply new model config") camera_client.set_overlay_state("off") if (camera_client.vam_running): camera_client.set_analytics_state("off") #time.sleep(1) camera_client.set_analytics_state("on") camera_client.set_overlay_state("on") #self.print_and_send_results() except Exception as e: logger.debug( "System got an exception during vam ON off after twin model update!!! " ) logger.exception(e) #self.restart_cam(camera_client) raise