def iothub_file_upload_sample_run(): try: print("IoT Hub file upload sample, press Ctrl-C to exit") client = IoTHubClient(CONNECTION_STRING, PROTOCOL) f = open(PATHTOFILE, "r") content = f.read() client.upload_blob_async(FILENAME, content, len(content), blob_upload_conf_callback, 0) print("") print("File upload initiated...") while True: time.sleep(30) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped") except: print("generic error")
def iothub_file_upload_sample_run(): try: print("IoT Hub file upload sample, press Ctrl-C to exit") client = IoTHubClient(CONNECTION_STRING, PROTOCOL) f = open(PATHTOFILE, "r") content = f.read() # Please note that because of the way the C SDK wrapper is written, file upload is limited to text files. # The last parameter of this method call is user_context. # it will be passed to the blob_upload_conf_callback so that calls and callbacks can be matched together # in case there are multiple simultaneous uploads client.upload_blob_async(FILENAME, content, len(content), blob_upload_conf_callback, 0) print("") print("File upload initiated...") while True: time.sleep(30) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient sample stopped") except: print("generic error")
def upload_file_through_iothub(conn_str: str, path_to_file: str = PATHTOFILE, file_name: str = FILENAME): try: print("Upload file through IoT Hub.") client = IoTHubClient(conn_str, PROTOCOL) f = open(path_to_file, "r") content = f.read() user_context = {"file_name": path_to_file, "done": False} client.upload_blob_async(file_name, content, len(content), blob_upload_conf_callback, user_context) print("") print("File upload initiated...") while True: if user_context["done"]: return time.sleep(1) except IoTHubError as iothub_error: print("Unexpected error %s from IoTHub" % iothub_error) return except KeyboardInterrupt: print("IoTHubClient stopped") except: print("generic error")
def iothub_file_upload(): client = IoTHubClient(HUB_CONNECTION_STRING, BLOB_PROTOCOL) f = open(PATHTOFILE + FILENAME, "rb") content = base64.b64encode(f.read()) client.upload_blob_async(FILENAME, content, len(content), blob_upload_conf_callback, 0) iothub_client_post_message()
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)
class Uploader(object): def __init__(self, publish_interval, upload_files_root_dir, connection_string): self.interval = publish_interval self.file_root_dir = upload_files_root_dir # create the scheduler self.s = sched.scheduler(time.time, time.sleep) # create the client self.client = IoTHubClient(connection_string, IoTHubTransportProvider.MQTT) self.client.set_option("messageTimeout", MESSAGE_TIMEOUT) def __upload_to_blob(self, destination_filename, source, size, user_context): # upload blob using IotHubClient self.client.upload_blob_async(destination_filename, source, size, blob_upload_conf_callback, user_context) def __upload_avro_files(self, sc): # find all of the files written by the module file_search = os.path.join(self.file_root_dir, "**/*.avro") files = glob.glob(file_search, recursive=True) for file in files: # upload only files not modified in the last 10 minutes if (time.time() - os.path.getmtime(file)) > MODIFIED_FILE_TIMEOUT: f = open(file, "rb") content = f.read() print("Starting upload for file: %s" % file) self.__upload_to_blob(file[1:], content, len(content), file) # schedule this method to be called by scheduler after self.interval self.s.enter(self.interval, 1, self.__upload_avro_files, (sc, )) def run_schedule(self): # __upload_avro_files to run after self.interval self.s.enter(self.interval, 1, self.__upload_avro_files, (self.s, )) self.s.run()
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 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)