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 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(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) 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(): # 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(): # 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(): logger.info("Initializing iothub_client") client = IoTHubClient(CONNECTION_STRING, PROTOCOL) if client.protocol == IoTHubTransportProvider.MQTT: client.set_option("logtrace", 0) client.set_device_method_callback(device_method_callback, 0) 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_message_callback(receive_message_callback, RECEIVE_CONTEXT) if client.protocol == IoTHubTransportProvider.MQTT or client.protocol == IoTHubTransportProvider.MQTT_WS: client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) return client
def iothub_connect(): client = IoTHubClient(CONNECTION_STRING, PROTOCOL) client.set_option('product_info', 'Adaran-Pi-Py') # If we're using HTTP, we should set timeout (distinct from messageTimeout) and minimum polling time here client.set_option('messageTimeout', MESSAGE_TIMEOUT) client.set_option('logtrace', 1) client.set_message_callback(receive_message_callback, RECEIVE_CONTEXT) client.set_device_method_callback(device_method_callback, METHOD_CONTEXT) return client
def main(): initialize_grovepi() client = IoTHubClient(DEVICE_CONNECTION_STRING, PROTOCOL) client.set_device_method_callback(device_method_cb, None) global EXIT while not EXIT: print('.') sleep(1) print('Exiting...')
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) client.set_option("product_info", "RaspberryPi_test_button") client.set_option("messageTimeout", MESSAGE_TIMEOUT) client.set_message_callback(device_method_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) # set the time until a message times out client.set_option("messageTimeout", MESSAGE_TIMEOUT) client.set_option("logtrace", 0) client.set_device_method_callback( device_method_callback, METHOD_CONTEXT) #Anger vilken metod som anropas för att ta emot Method client.set_message_callback( receive_message_callback, RECEIVE_CONTEXT) #Anger vilken medotd för hantering av meddelanden 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
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
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) 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
device_method_return_value.status = 404 return device_method_return_value def send_confirmation_callback(message, result, user_context): print("IoT Hub responded to message with status: %s" % (result)) print("Parsing Args") args = build_argparser().parse_args() print("connectionstring") print(args.connectionstring) if enable_cloud_output: client = IoTHubClient(args.connectionstring, PROTOCOL) client.set_device_method_callback(device_method_callback, None) if enable_local_jpeg_output: local_output_dir = os.environ.get("OUTPUT_DIR") assert os.path.isdir( local_output_dir), "Specified output directory doesn't exist" print("writing output jpeg frames to " + local_output_dir) # Define the JSON message to send to IoT Hub. def report_output(frame, res_json): json_string = json.dumps(res_json) print("Classification output: " + json_string) if enable_cloud_output: message = IoTHubMessage(json_string) print("Sending message: %s" % message.get_string())
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))
class IotHub: def __init__(self, hardware, queue): self.method_callbacks = 0 self.hardware = hardware self.queue = queue self._init_client() def _init_client(self): # Connect to iot-hub self.client = IoTHubClient(IOTHUB_CONNECTION, IoTHubTransportProvider.AMQP) # Settings self.client.set_option("messageTimeout", IOTHUB_MESSAGE_TIMEOUT) self.client.set_device_method_callback(self.device_method_callback, 0) def send_confirmation_callback(self, message, result, user_context): print( "Confirmation received for message with result {}".format(result)) print(" message_id: %s" % message.message_id) print(" correlation_id: %s" % message.correlation_id) def send_message(self, payload): message_id = uuid4() message = IoTHubMessage(bytearray(payload, 'utf8')) self.client.send_event_async(message, self.send_confirmation_callback, message_id) print("Message {} accepted for transmission to IoT Hub.".format( message_id)) return self.client.get_send_status() # Gets invoked by message from the cloud def device_method_callback(self, method_name, payload, user_context): print( "Method callback called with: methodName = {}, payload = {}, context = {}" .format(method_name, payload, user_context)) msg = json.loads(payload) try: if method_name == 'list': response = self.hardware.list_methods() elif method_name == 'cancel': self.queue.cancel() response = "ok" else: method_payload = msg['payload'] if 'payload' in msg else {} self.queue.append("invoke_method", { "method": method_name, "payload": method_payload, }) response = "ok" status = 200 except NotImplementedError: response = 'Method not defined' status = 404 except ValueError as inst: response = inst.args status = 400 except queue.Full: response = "Too many items in queue" status = 503 except Exception as inst: response = inst.args status = 500 return_value = DeviceMethodReturnValue() return_value.status = status return_value.response = json_dumps({'Response': response}) return return_value
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"
def run_e2e_devicemethod(iothub_connection_string): global DEVICE_METHOD_USER_CONTEXT global DEVICE_METHOD_NAME global DEVICE_METHOD_PAYLOAD global DEVICE_METHOD_TIMEOUT try: # prepare device_id = generate_device_name() assert isinstance(device_id, str), 'Invalid type returned!' primary_key = "" secondary_key = "" auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY iothub_registry_manager = IoTHubRegistryManager(iothub_connection_string) new_device = iothub_registry_manager.create_device(device_id, primary_key, secondary_key, auth_method) device_connection_string = get_device_connection_string(iothub_registry_manager, IOTHUB_CONNECTION_STRING, device_id) device_client = IoTHubClient(device_connection_string, IoTHubTransportProvider.MQTT) assert isinstance(device_client, IoTHubClient), 'Invalid type returned!' assert device_client != None, "device_client is NULL" device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT) device_client.set_device_method_callback(device_method_callback, DEVICE_METHOD_USER_CONTEXT) ########################################################################### # IoTHubDeviceMethod # prepare # act iothub_device_method = IoTHubDeviceMethod(IOTHUB_CONNECTION_STRING) # verify assert iothub_device_method != None, "iothub_device_method is NULL" ########################################################################### # Wait before invoke... time.sleep(SLEEP_BEFORE_DEVICE_ACTION) ############################################################################ # invoke # prepare # act response = iothub_device_method.invoke(device_id, DEVICE_METHOD_NAME, DEVICE_METHOD_PAYLOAD, DEVICE_METHOD_TIMEOUT) assert response != None, "response is NULL" assert isinstance(response, IoTHubDeviceMethodResponse), 'Invalid type returned!' # verify response_ok = response.payload.find(DEVICE_CLIENT_RESPONSE) assert response_ok > 0, "response does not contain " + DEVICE_CLIENT_RESPONSE assert response.status == 200, "response status is : " + response.status DEVICE_METHOD_EVENT.wait(DEVICE_METHOD_CALLBACK_TIMEOUT) assert DEVICE_CLIENT_RESPONSE.find(DEVICE_METHOD_RESPONSE_PREFIX) >= 0, "Timeout expired and device method has not been called!" ############################################################################ print ( "" ) retval = 0 except Exception as e: print ( "" ) print ("run_e2e_devicemethod() failed with exception: {0}".format(e)) retval = 1 finally: # clean-up iothub_registry_manager.delete_device(device_id) return retval
def run_e2e_method(iothub_connection_string, testing_modules): global DEVICE_METHOD_USER_CONTEXT global DEVICE_METHOD_NAME global DEVICE_METHOD_PAYLOAD global DEVICE_METHOD_TIMEOUT try: # prepare device_id = generate_device_name() assert isinstance(device_id, str), 'Invalid type returned!' primary_key = "" secondary_key = "" auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY iothub_registry_manager = IoTHubRegistryManager( iothub_connection_string) new_device = iothub_registry_manager.create_device( device_id, primary_key, secondary_key, auth_method) if testing_modules == True: new_module = iothub_registry_manager.create_module( device_id, primary_key, secondary_key, TEST_MODULE_ID, auth_method) protocol = IoTHubTransportProvider.AMQP else: protocol = IoTHubTransportProvider.MQTT connection_string = get_connection_string(iothub_registry_manager, IOTHUB_CONNECTION_STRING, device_id, testing_modules) device_client = IoTHubClient(connection_string, protocol) assert isinstance(device_client, IoTHubClient), 'Invalid type returned!' assert device_client != None, "device_client is NULL" device_client.set_option("messageTimeout", DEVICE_MESSAGE_TIMEOUT) device_client.set_device_method_callback(device_method_callback, DEVICE_METHOD_USER_CONTEXT) ########################################################################### # IoTHubDeviceMethod # prepare # act iothub_device_method = IoTHubDeviceMethod(IOTHUB_CONNECTION_STRING) # verify assert iothub_device_method != None, "iothub_device_method is NULL" ########################################################################### # Wait before invoke... sleep_before_device_action() ############################################################################ # invoke # prepare # act if testing_modules == True: response = iothub_device_method.invoke(device_id, TEST_MODULE_ID, DEVICE_METHOD_NAME, DEVICE_METHOD_PAYLOAD, DEVICE_METHOD_TIMEOUT) else: response = iothub_device_method.invoke(device_id, DEVICE_METHOD_NAME, DEVICE_METHOD_PAYLOAD, DEVICE_METHOD_TIMEOUT) assert response != None, "response is NULL" assert isinstance(response, IoTHubDeviceMethodResponse), 'Invalid type returned!' # verify response_ok = response.payload.find(DEVICE_CLIENT_RESPONSE) assert response_ok > 0, "response does not contain " + DEVICE_CLIENT_RESPONSE assert response.status == 200, "response status is : " + response.status DEVICE_METHOD_EVENT.wait(DEVICE_METHOD_CALLBACK_TIMEOUT) assert DEVICE_CLIENT_RESPONSE.find( DEVICE_METHOD_RESPONSE_PREFIX ) >= 0, "Timeout expired and device method has not been called!" ############################################################################ print("") retval = 0 except Exception as e: print("") print("run_e2e_method() failed with exception: {0}".format(e)) retval = 1 finally: # clean-up iothub_registry_manager.delete_device(device_id) return retval
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)
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