def iothubClientInit(self): # prepare iothub client client = IoTHubClient(self.CONNECTION_STRING, PROTOCOL) client.set_option("product_info", "HappyPath_RaspberryPi-Python") if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) # set callback after a message is received client.set_message_callback(self.receiveMessageCallback, RECEIVE_CONTEXT) # if MQTT or MQTT_WS is used -> set device twin callback if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(self.deviceTwinCallback, TWIN_CONTEXT) client.set_device_method_callback(self.deviceMethodCallback, METHOD_CONTEXT) return client
def iothub_client_init(self): # prepare iothub client client = IoTHubClient(self.connectionString, IoTHubTransportProvider.MQTT) # set the time until a message times out client.set_option("messageTimeout", self.MESSAGE_TIMEOUT) client.set_option("logtrace", 0) client.set_message_callback(self.receive_message_callback, self.RECEIVE_CONTEXT) client.set_device_twin_callback(self.device_twin_callback, self.TWIN_CONTEXT) client.set_device_method_callback(self.device_method_callback, self.METHOD_CONTEXT) client.set_connection_status_callback(self.connection_status_callback, self.CONNECTION_STATUS_CONTEXT) retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL retryInterval = 100 client.set_retry_policy(retryPolicy, retryInterval) logger.log("SetRetryPolicy to: retryPolicy = {0}".format(retryPolicy)) logger.log( "SetRetryPolicy to: retryTimeoutLimitInSeconds = {0}".format( retryInterval)) retryPolicyReturn = client.get_retry_policy() logger.log("GetRetryPolicy returned: retryPolicy = {0}".format( retryPolicyReturn.retryPolicy)) logger.log( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = {0}\n". format(retryPolicyReturn.retryTimeoutLimitInSeconds)) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information set_certificates(client) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback( receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback( device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback( device_method_callback, METHOD_CONTEXT) return client
def iothub_client_init(self): log = logger.getLogger() # prepare iothub client log.debug("- creating the client with {0} {1} {2} {3}".format( self.iothub_uri, self.device_id, self.security_type.name, self.protocol.name)) client = IoTHubClient(self.iothub_uri, self.device_id, self.security_type, self.protocol) # set the time until a message times out client.set_option("messageTimeout", self.MESSAGE_TIMEOUT) client.set_option("logtrace", 0) client.set_message_callback(self.receive_message_callback, self.RECEIVE_CONTEXT) client.set_device_twin_callback(self.device_twin_callback, self.TWIN_CONTEXT) client.set_device_method_callback(self.device_method_callback, self.METHOD_CONTEXT) client.set_connection_status_callback(self.connection_status_callback, self.CONNECTION_STATUS_CONTEXT) retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL retryInterval = 100 client.set_retry_policy(retryPolicy, retryInterval) log.info("SetRetryPolicy to: retryPolicy = {0}".format(retryPolicy)) log.info("SetRetryPolicy to: retryTimeoutLimitInSeconds = {0}".format( retryInterval)) retryPolicyReturn = client.get_retry_policy() log.info("GetRetryPolicy returned: retryPolicy = {0}".format( retryPolicyReturn.retryPolicy)) log.info("GetRetryPolicy returned: retryTimeoutLimitInSeconds = {0}\n". format(retryPolicyReturn.retryTimeoutLimitInSeconds)) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information set_certificates(client) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback( receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback( device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback( device_method_callback, METHOD_CONTEXT) if client.protocol == IoTHubTransportProvider.AMQP or client.protocol == IoTHubTransportProvider.AMQP_WS: client.set_connection_status_callback( connection_status_callback, CONNECTION_STATUS_CONTEXT) retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL retryInterval = 100 client.set_retry_policy(retryPolicy, retryInterval) print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy) print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval) retryPolicyReturn = client.get_retry_policy() print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy) print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds) return client
def iothub_client_init(ConString, Proto): logging.basicConfig(filename='smartlib{0}.log'.format(dt.date.today().isocalendar()[1]), level=logging.DEBUG) # prepare iothub client print("ConString {0}".format(ConString)) client = IoTHubClient(ConString, Proto) if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information set_certificates(client) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback( receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback( device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback( device_method_callback, METHOD_CONTEXT) if client.protocol == IoTHubTransportProvider.AMQP or client.protocol == IoTHubTransportProvider.AMQP_WS: client.set_connection_status_callback( connection_status_callback, CONNECTION_STATUS_CONTEXT) retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL retryInterval = 0 client.set_retry_policy(retryPolicy, retryInterval) print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy) print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval) retryPolicyReturn = client.get_retry_policy() print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy) print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds) return client
def iothub_client_init(): global client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information set_certificates(client) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback( receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback( device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback( device_method_callback, METHOD_CONTEXT) if client.protocol == IoTHubTransportProvider.AMQP or client.protocol == IoTHubTransportProvider.AMQP_WS: client.set_connection_status_callback( connection_status_callback, CONNECTION_STATUS_CONTEXT) retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL retryInterval = 100 client.set_retry_policy(retryPolicy, retryInterval) print ( "SetRetryPolicy to: retryPolicy = %d" % retryPolicy) print ( "SetRetryPolicy to: retryTimeoutLimitInSeconds = %d" % retryInterval) retryPolicyReturn = client.get_retry_policy() print ( "GetRetryPolicy returned: retryPolicy = %d" % retryPolicyReturn.retryPolicy) print ( "GetRetryPolicy returned: retryTimeoutLimitInSeconds = %d" % retryPolicyReturn.retryTimeoutLimitInSeconds)
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) client.set_option("product_info", "HappyPath_RaspberryPi-Python") if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # to enable MQTT logging set to 1 # MQTT (Message Queuing Telemetry Transport) is an ISO standard, publish-subscribe based messaging protocol. # it works on the top of the TCP/IP protocol if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) # Device twins store device-related information that: # Device and back ends can use to synchronize device conditions and configuration. # The solution back end can use to query and target long-running operations. if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) return client
def iothub_client_init(self): client = IoTHubClient(self.CONNECTION_STRING, self.PROTOCOL) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(self.device_twin_callback, self.TWIN_CONTEXT) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) client.set_option("logtrace", 0) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(device_twin_callback, client) return client
def iothub_client_init(): client = IoTHubClient(CONNECTION_STRING, PROTOCOL) client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) client.set_option("messageTimeout", MESSAGE_TIMEOUT) client.set_option("logtrace", 0) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) # set options client.set_option("messageTimeout", MESSAGE_TIMEOUT) client.set_option("logtrace", 0) # set callbacks client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) #Turn on and off log tracing for the transport client.set_option("logtrace", 0) #Anger vilken metod som anropas för att ta emot Method client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) #Anger vilken medotd för hantering av meddelanden client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) client.set_device_twin_callback(device_twin_callback, METHOD_CONTEXT) #client.upload_blob_async(upload_to_blob, RECEIVE_CALLBACKS) return client
def iothub_client_init(): client = IoTHubClient(DEVICE_CONNECTION_STRING, PROTOCOL) client.set_option("product_info", "RaspberryPi") if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) client.set_option("messageTimeout", MESSAGE_TIMEOUT) if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) return client
class HubManager(object): def __init__( self, connection_string, protocol=IoTHubTransportProvider.MQTT): self.client_protocol = protocol self.client = IoTHubClient(connection_string, protocol) if protocol == IoTHubTransportProvider.HTTP: self.client.set_option("timeout", TIMEOUT) self.client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out self.client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information # self.set_certificates() self.client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) self.client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) self.client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) def set_certificates(self): from iothub_client_cert import CERTIFICATES try: self.client.set_option("TrustedCerts", CERTIFICATES) print ( "set_option TrustedCerts successful" ) except IoTHubClientError as iothub_client_error: print ( "set_option TrustedCerts failed (%s)" % iothub_client_error ) def send_event(self, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async( event, send_confirmation_callback, send_context) 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 upload_to_blob(self, destinationfilename, source, size, usercontext): self.client.upload_blob_async( destinationfilename, source, size, blob_upload_conf_callback, usercontext)
class HubManager(object): def __init__( self, connection_string, protocol=IoTHubTransportProvider.MQTT): self.client_protocol = protocol self.client = IoTHubClient(connection_string, protocol) if protocol == IoTHubTransportProvider.HTTP: self.client.set_option("timeout", TIMEOUT) self.client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out self.client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information # self.set_certificates() self.client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) self.client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) self.client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) def set_certificates(self): from iothub_client_cert import CERTIFICATES try: self.client.set_option("TrustedCerts", CERTIFICATES) print ( "set_option TrustedCerts successful" ) except IoTHubClientError as iothub_client_error: print ( "set_option TrustedCerts failed (%s)" % iothub_client_error ) def send_event(self, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async( event, send_confirmation_callback, send_context) 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 upload_to_blob(self, destinationfilename, source, size, usercontext): self.client.upload_blob_async( destinationfilename, source, size, blob_upload_conf_callback, usercontext)
def initialize_client(connection_string): # prepare iothub client client = IoTHubClient(connection_string, PROTOCOL) client.set_option("product_info", "HappyPath_RaspberryPi-Python") if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) client.set_option("logtrace", 0) client.set_message_callback(receive_message_callback, 0) retryPolicy = IoTHubClientRetryPolicy.RETRY_INTERVAL retryInterval = 100 client.set_retry_policy(retryPolicy, retryInterval) return client
def iothub_client_init(): # prepare iothub client client = IoTHubClient(CONNECTION_STRING, PROTOCOL) client.set_option("product_info", "HappyPath_RaspberryPi-Python") if client.protocol == IoTHubTransportProvider.HTTP: client.set_option("timeout", TIMEOUT) client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) # to enable MQTT logging set to 1 if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_message_callback( receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_twin_callback( device_twin_callback, TWIN_CONTEXT) client.set_device_method_callback( device_method_callback, METHOD_CONTEXT) return client
class HubManager(object): def __init__( self, connection_string): self.client_protocol = PROTOCOL self.client = IoTHubClient(connection_string, PROTOCOL) # set the time until a message times out self.client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information self.set_certificates() # set a TWIN callback self.client.set_device_twin_callback(device_twin_callback, self) # 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) def set_certificates(self): isWindows = sys.platform.lower() in ['windows', 'win32'] if not isWindows: CERT_FILE = os.environ['EdgeModuleCACertificateFile'] print("Adding TrustedCerts from: {0}".format(CERT_FILE)) # this brings in x509 privateKey and certificate file = open(CERT_FILE) try: self.client.set_option("TrustedCerts", file.read()) print ( "set_option TrustedCerts successful" ) except IoTHubClientError as iothub_client_error: print ( "set_option TrustedCerts failed (%s)" % iothub_client_error ) file.close() # 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 Sender(object): def __init__(self, connection_string, certificate_path=False, protocol=PROTOCOL): self.client_protocol = protocol self.client = IoTHubClient(connection_string, protocol) # set the time until a message times out self.client.set_option('messageTimeout', MESSAGE_TIMEOUT) # sets the callback when a twin's desired properties are updated. self.client.set_device_twin_callback(device_twin_callback, self) # some embedded platforms need certificate information if certificate_path: self.set_certificates(certificate_path) def set_certificates(self, certificate_path): file = open(certificate_path, 'r') try: self.client.set_option('TrustedCerts', file.read()) print('IoT Edge TrustedCerts set successfully') except IoTHubClientError as iothub_client_error: print('Setting IoT Edge TrustedCerts failed (%s)' % iothub_client_error) file.close() def send_event_to_output(self, outputQueueName, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) if len(properties) > 0: prop_map = event.properties() for key in properties: prop_map.add_or_update(key, properties[key]) self.client.send_event_async(outputQueueName, event, send_confirmation_callback, send_context)
class DeviceClient(object): def __init__(self, connection_string, protocol=IoTHubTransportProvider.MQTT): print("Device Client __init__ ....creating IoTHubClient connection!") print("Connection String = %s" % connection_string) self.client_protocol = protocol self.client = IoTHubClient(connection_string, protocol) if protocol == IoTHubTransportProvider.HTTP: self.client.set_option("timeout", TIMEOUT) self.client.set_option("MinimumPollingTime", MINIMUM_POLLING_TIME) # set the time until a message times out self.client.set_option("messageTimeout", MESSAGE_TIMEOUT) # some embedded platforms need certificate information # self.set_certificates() self.client.set_message_callback(self.receive_message_callback, RECEIVE_CONTEXT) self.client.set_device_twin_callback(self.device_twin_callback, TWIN_CONTEXT) self.client.set_device_method_callback(self.device_method_callback, METHOD_CONTEXT) def set_certificates(self, client): from iothub_client_cert import CERTIFICATES try: self.client.set_option("TrustedCerts", CERTIFICATES) print("set_option TrustedCerts successful") except IoTHubClientError as iothub_client_error: print("set_option TrustedCerts failed (%s)" % iothub_client_error) def send_event(self, event, properties, send_context): if not isinstance(event, IoTHubMessage): event = IoTHubMessage(bytearray(event, 'utf8')) # if len(properties) > 0: # prop_map = event.properties() # for key in properties: # prop_map.add_or_update(key, properties[key]) self.client.send_event_async(event, self.send_confirmation_callback, send_context) def send_reported_state(self, reported_state, size, user_context): self.client.send_reported_state(reported_state, size, self.send_reported_state_callback, user_context) def upload_to_blob(self, destinationfilename, source, size, usercontext): self.client.upload_blob_async(destinationfilename, source, size, self.blob_upload_conf_callback, usercontext) 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(" Properties: %s" % key_value_pair) SEND_CALLBACKS += 1 print(" Total calls confirmed: %d" % SEND_CALLBACKS) def receive_message_callback(self, message, counter): global RECEIVE_CALLBACKS message_buffer = message.get_bytearray() size = len(message_buffer) print("<SimDevice> Received Message [%d]:" % counter) print(" Data: <<<%s>>> & Size=%d" % (message_buffer[:size].decode('utf-8'), size)) map_properties = message.properties() key_value_pair = map_properties.get_internals() print(" Properties: %s" % key_value_pair) counter += 1 RECEIVE_CALLBACKS += 1 print(" Total calls received: %d" % RECEIVE_CALLBACKS) return IoTHubMessageDispositionResult.ACCEPTED def device_twin_callback(self, update_state, payload, user_context): global TWIN_CALLBACKS print( "\nTwin callback called with:\nupdateStatus = %s\npayload = %s\ncontext = %s" % (update_state, payload, user_context)) TWIN_CALLBACKS += 1 print("Total calls confirmed: %d\n" % TWIN_CALLBACKS) def send_reported_state_callback(self, status_code, user_context): global SEND_REPORTED_STATE_CALLBACKS print( "Confirmation for reported state received with:\nstatus_code = [%d]\ncontext = %s" % (status_code, user_context)) SEND_REPORTED_STATE_CALLBACKS += 1 print(" Total calls confirmed: %d" % SEND_REPORTED_STATE_CALLBACKS) def device_method_callback(self, method_name, payload, user_context): global METHOD_CALLBACKS print( "\nMethod callback called with:\nmethodName = %s\npayload = %s\ncontext = %s" % (method_name, payload, user_context)) METHOD_CALLBACKS += 1 print("Total calls confirmed: %d\n" % METHOD_CALLBACKS) device_method_return_value = DeviceMethodReturnValue() device_method_return_value.response = "{ \"Response\": \"This is the response from the device\" }" device_method_return_value.status = 200 return device_method_return_value def blob_upload_conf_callback(self, result, user_context): global BLOB_CALLBACKS print( "Blob upload confirmation[%d] received for message with result = %s" % (user_context, result)) BLOB_CALLBACKS += 1 print(" Total calls confirmed: %d" % BLOB_CALLBACKS) def connection_status_callback(self, result, reason, user_context): global CONNECTION_STATUS_CALLBACKS print("Connection status changed[%d] with:" % (user_context)) print(" reason: %d" % reason) print(" result: %s" % result) CONNECTION_STATUS_CALLBACKS += 1 print(" Total calls confirmed: %d" % CONNECTION_STATUS_CALLBACKS)
def run_e2e_device_client(iothub_service_client_messaging, iothub_device_method, iothub_device_twin, device_id, device_connection_string, protocol, authMethod): ########################################################################### # IoTHubClient # prepare # act device_client = IoTHubClient(device_connection_string, protocol) # verify assert isinstance(device_client, IoTHubClient), 'Error: Invalid type returned!' 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_THUMBPRINT) if device_client.protocol == IoTHubTransportProvider.HTTP: device_client.set_option("timeout", HTTP_TIMEOUT) device_client.set_option("MinimumPollingTime", HTTP_MINIMUM_POLLING_TIME) if protocol == IoTHubTransportProvider.MQTT_WS or protocol == IoTHubTransportProvider.AMQP_WS: device_client.set_option("TrustedCerts", CERTIFICATES) # verify ########################################################################### ########################################################################### # set_message_callback # prepare # act device_client.set_message_callback(receive_message_callback, MESSAGING_CONTEXT) # verify ########################################################################### if protocol == IoTHubTransportProvider.MQTT or protocol == IoTHubTransportProvider.MQTT_WS: ########################################################################### # set_device_twin_callback # prepare # act device_client.set_device_twin_callback(device_twin_callback, MESSAGING_CONTEXT) # verify ########################################################################### ########################################################################### # set_device_method_callback # prepare # act 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) TWIN_CALLBACK_EVENT.wait(CALLBACK_TIMEOUT) # verify assert TWIN_CALLBACK_COUNTER == 1, "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) DEVICE_METHOD_EVENT.wait(CALLBACK_TIMEOUT) # verify assert DEVICE_METHOD_CALLBACK_COUNTER == 1, "Error: device_twin_callback callback has not been called" ########################################################################### if protocol != IoTHubTransportProvider.AMQP \ and protocol != IoTHubTransportProvider.AMQP_WS \ and protocol != IoTHubTransportProvider.HTTP: ########################################################################### # 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 == 1, "Error: send_reported_state_callback has not been called" ########################################################################### ########################################################################### # 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) MESSAGE_RECEIVE_EVENT.wait(CALLBACK_TIMEOUT) # verify assert MESSAGE_RECEIVE_CALLBACK_COUNTER == 1, "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" ########################################################################### ########################################################################### # 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 == 1, "Error: blob_upload_conf_callback callback has not been called" ########################################################################### print ("run_e2e_device_client with protocol: {0}, and authMethod: {1} finished".format(protocol, authMethod))
def run_e2e_device_client(iothub_service_client_messaging, iothub_device_method, iothub_device_twin, device_id, device_connection_string, protocol, authMethod): global IOTHUB_E2E_X509_CERT global IOTHUB_E2E_X509_THUMBPRINT global IOTHUB_E2E_X509_PRIVATE_KEY global CERTIFICATES global MESSAGING_CONTEXT ########################################################################### # IoTHubClient # prepare # act device_client = IoTHubClient(device_connection_string, protocol) # verify assert isinstance(device_client, IoTHubClient), 'Error: Invalid type returned!' 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 ########################################################################### ########################################################################### # 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.MQTT or protocol == IoTHubTransportProvider.MQTT_WS: ########################################################################### # set_device_twin_callback # prepare # act device_client.set_device_twin_callback(device_twin_callback, MESSAGING_CONTEXT) # verify ########################################################################### ########################################################################### # set_device_method_callback # prepare # act 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) 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) DEVICE_METHOD_EVENT.wait(CALLBACK_TIMEOUT) # verify assert DEVICE_METHOD_CALLBACK_COUNTER > 0, "Error: device_twin_callback callback has not been called" ########################################################################### if protocol == IoTHubTransportProvider.AMQP \ or protocol == IoTHubTransportProvider.AMQP_WS \ or protocol == IoTHubTransportProvider.MQTT \ or protocol == IoTHubTransportProvider.MQTT_WS: ########################################################################### # 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) ########################################################################### # 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) 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" ########################################################################### ########################################################################### # 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 Azure: def __init__(self, application, device_config): global azure_singelton if azure_singelton is None: azure_singelton = self else: raise Exception("AZURE: AzureIot instance already created") with open('azure.json') as f: self.config = json.load(f) if self.config['connection_string'].find(device_config.deviceid) == -1: raise Exception( "Azure connection string does not match configured device id") self.application = application self.hubClient = IoTHubClient(self.config['connection_string'], PROTOCOL) if self.hubClient.protocol == IoTHubTransportProvider.MQTT or self.hubClient.protocol == IoTHubTransportProvider.MQTT_WS: self.hubClient.set_device_twin_callback(device_twin_callback, TWIN_CONTEXT) # Report current state to cloud def update_reported_state(self, reported): try: # Report new state to HUB reported_state = json.dumps(reported) self.hubClient.send_reported_state(reported_state, len(reported_state), send_reported_state_callback, SEND_REPORTED_STATE_CONTEXT) return True except IoTHubError as iothub_error: print( "AZURE: Unexpected error from IoTHub when reporting state: %s" % iothub_error) return False # Post telemetry to cloud def post_telemetry(self, telemetry): try: message = IoTHubMessage(json.dumps(telemetry)) self.hubClient.send_event_async(message, send_confirmation_callback, None) return True except IoTHubError as iothub_error: print( "AZURE: Unexpected error from IoTHub when posting telemetry: %s" % iothub_error) return False # Keep cloud connection open (not needed for azure) def kick(self): pass # Local callbacks from iot_client def device_twin_callback(self, update_state, payload, user_context): print("AZURE: Twin callback called with updateStatus: '%s'" % update_state) payload_json = json.loads(payload) if update_state == iothub_client.iothub_client.IoTHubTwinUpdateState.COMPLETE: desired_state = payload_json["desired"].copy() else: desired_state = payload_json.copy() self.application.device_twin_update(desired_state) def send_confirmation_callback(self, message, result, user_context): print("AZURE: IoT Hub responded to message with status: %s" % (result)) def send_reported_state_callback(self, status_code, user_context): print( "AZURE: Confirmation for reported state called with status_code: %d" % status_code)
print ( " correlation_id: %s" % message.correlation_id ) SEND_CALLBACKS += 1 print ( " Total calls confirmed: %d" % SEND_CALLBACKS ) status, result, connect_string = sas_token.get_connection_string() if status != return_values.OK: print("Connection request has failed. Response: {}".format(return_values.RetValDescription(result))) print("Quitting") else: print("Connection request success. String: {}".format(connect_string)) client = IoTHubClient(connect_string.encode("utf-8"), IoTHubTransportProvider.MQTT) client.set_option("logtrace", 0) client.set_message_callback( receive_message_callback, CONTEXT) client.set_device_twin_callback( device_twin_callback, CONTEXT) client.set_device_method_callback( device_method_callback, CONTEXT) message_counter = 0 while True: val = raw_input("Press a key\n") if val == 'q': break else: print("Sending message") message = IoTHubMessage("Test Message") message.message_id = "message_%d" % message_counter message.correlation_id = "correlation_%d" % message_counter client.send_event_async(message, send_confirmation_callback, message_counter) message_counter += 1