Hologram Python SDK v0.7.0 release

Author: tzhenghao

.gitignore

@@ -49,6 +49,9 @@ coverage.xml
 *.mo
 *.pot
 
+# Jetbrains IDE stuff
+.idea
+
 # Django stuff:
 *.log
 local_settings.py

ChangeLog

@@ -1,3 +1,17 @@
+2017-10-24 Hologram <[email protected]>
+    * Added modem is_connected interface. Checks for when a message/SMS can be sent.
+    * Cleaned up example scripts.
+
+2017-10-23 Hologram <[email protected]>
+    * Added hologram network connect/disconnect CLI commands, deprecating
+      modem connect/disconnect soon.
+    * Writes/reads on AT command sockets are now done in hex mode.
+    * Fix regression where a receive SMS CLI keyboard interrupt will print a
+      stack trace.
+
+2017-10-20 Hologram <[email protected]>
+    * Sends/receives are done via AT sockets by default instead of a PPP session.
+
 2017-09-29 Hologram <[email protected]>
     * Fixed bug where empty result list might cause an index error
 

Hologram/Cloud.py

@@ -13,7 +13,7 @@
 from Network import NetworkManager
 from Authentication import *
 
-__version__ = '0.6.1'
+__version__ = '0.7.0'
 
 class Cloud(object):
 

Hologram/CustomCloud.py

@@ -19,7 +19,7 @@
 MAX_QUEUED_CONNECTIONS = 5
 RECEIVE_TIMEOUT = 5
 SEND_TIMEOUT = 5
-MIN_PERIODIC_INTERVAL = 30
+MIN_PERIODIC_INTERVAL = 1
 
 class CustomCloud(Cloud):
 
@@ -54,11 +54,14 @@ def __init__(self, credentials, send_host='', send_port=0,
         if enable_inbound == True:
             self.initializeReceiveSocket()
 
+    def is_ready_to_send(self):
+        return self.network is None or self.network.is_connected()
+
     # EFFECTS: Sends the message to the cloud.
     def sendMessage(self, message, timeout=SEND_TIMEOUT):
 
         try:
-            if not self._networkManager.networkActive:
+            if not self.is_ready_to_send():
                 self.addPayloadToBuffer(message)
                 return ''
 
@@ -67,10 +70,14 @@ def sendMessage(self, message, timeout=SEND_TIMEOUT):
             self.logger.info("Sending message with body of length %d", len(message))
             self.logger.debug('Send: %s', message)
 
-            self.sock.send(message)
-            self.logger.info('Sent.')
+            resultbuf = ''
+            if self.__to_use_at_sockets():
+                resultbuf = self.network.send_message(message)
+            else:
+                self.sock.send(message)
+                resultbuf = self.receive_send_socket()
 
-            resultbuf = self.receive_send_socket()
+            self.logger.info('Sent.')
 
             self.close_send_socket()
 
@@ -96,23 +103,35 @@ def open_send_socket(self, timeout=SEND_TIMEOUT):
             self.logger.info("Connecting to: %s", self.send_host)
             self.logger.info("Port: %s", self.send_port)
 
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            self.sock.settimeout(timeout)
-            self.sock.connect((self.send_host, self.send_port))
+            # Check if we're going to use the AT command version of sockets or the
+            # native Python socket lib.
+            if self.__to_use_at_sockets():
+                self.network.create_socket()
+                self.network.connect_socket(self.send_host, self.send_port)
+            else:
+                self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self.sock.settimeout(timeout)
+                self.sock.connect((self.send_host, self.send_port))
+
             self._is_send_socket_open = True
         except (IOError):
             self.logger.error('An error occurred while attempting to send the message to the cloud')
             self.logger.error('Please try again.')
 
     def close_send_socket(self):
         try:
+            # Check if we're going to use the AT command version of sockets or the
+            # native Python socket lib.
+            if self.__to_use_at_sockets():
+                self.network.close_socket()
+            else:
+                try:
+                    self.sock.shutdown(socket.SHUT_RDWR)
+                except socket.error:
+                    pass
+
+                self.sock.close()
 
-            try:
-                self.sock.shutdown(socket.SHUT_RDWR)
-            except socket.error:
-                pass
-
-            self.sock.close()
             self._is_send_socket_open = False
             self.logger.info('Socket closed.')
         except (IOError):
@@ -163,6 +182,10 @@ def sendPeriodicMessage(self, interval, message, topics=None, timeout=5):
     def sendSMS(self, destination_number, message):
         raise NotImplementedError('Cannot send SMS via custom cloud')
 
+
+    def __to_use_at_sockets(self):
+        return self.network is not None and self.network.at_sockets_available
+
     # EFFECTS: This threaded infinite loop shoud keep sending messages with the specified
     #          interval.
     def _periodic_job_thread(self, interval, function, *args):
@@ -198,6 +221,10 @@ def openReceiveSocket(self):
 
         self.__enforce_receive_host_and_port()
 
+        if self.__to_use_at_sockets():
+            self.network.open_receive_socket(self.receive_port)
+            return True
+
         self._receive_cv.acquire()
         self._receive_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self._receive_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -246,10 +273,14 @@ def open_receive_socket_helper(self):
     # EFFECTS: Closes the inbound socket connection.
     def closeReceiveSocket(self):
 
-        self._receive_cv.acquire()
-
         self.logger.info('Closing socket...')
 
+        if self.__to_use_at_sockets():
+            self.network.close_socket()
+            return
+
+        self._receive_cv.acquire()
+
         self.socketClose = True
         self._receive_cv.release()
 
@@ -260,12 +291,13 @@ def closeReceiveSocket(self):
             self._receive_socket.shutdown(socket.SHUT_RDWR)
         except socket.error:
             pass
-
         self._receive_socket.close()
-        self.logger.info('Socket closed.')
 
         self._receive_cv.release()
 
+        self.logger.info('Socket closed.')
+
+
     def acceptIncomingConnection(self):
         # This threaded infinite loop shoud keep listening on an incoming connection
         while True:
@@ -320,6 +352,10 @@ def __incoming_connection_thread(self, clientsocket):
 
     # EFFECTS: Returns the receive buffer and empties it.
     def popReceivedMessage(self):
+
+        if self.__to_use_at_sockets():
+            return self.network.pop_received_message()
+
         self._receive_buffer_lock.acquire()
 
         if len(self._receive_buffer) == 0:

Hologram/HologramCloud.py

@@ -14,7 +14,6 @@
 from CustomCloud import CustomCloud
 from Authentication import *
 from Exceptions.HologramError import HologramError
-import Event
 
 from HologramAuth.TOTPAuthentication import TOTPAuthentication
 from HologramAuth.SIMOTPAuthentication import SIMOTPAuthentication
@@ -69,6 +68,9 @@ def __init__(self, credentials, enable_inbound=False, network='',
 
         self.setAuthenticationType(credentials, authentication_type=authentication_type)
 
+        if self.authenticationType == 'totp':
+            self.__populate_totp_credentials()
+
     # EFFECTS: Authentication Configuration
     def setAuthenticationType(self, credentials, authentication_type='csrpsk'):
 
@@ -82,36 +84,30 @@ def setAuthenticationType(self, credentials, authentication_type='csrpsk'):
     # EFFECTS: Sends the message to the cloud.
     def sendMessage(self, message, topics = None, timeout = 5):
 
-        if not self._networkManager.networkActive:
+        if not self.is_ready_to_send():
             self.addPayloadToBuffer(message)
             return ''
 
+        # Set the appropriate credentials required for sim otp authentication.
+        if self.authenticationType == 'sim-otp':
+            self.__populate_sim_otp_credentials()
+
         modem_type = None
         modem_id = None
         if self.network is not None:
             modem_id = self.network.modem_id
             modem_type = str(self.network.modem)
 
-        # Set the approriate credentials required for sim otp authentication.
-        if self.authenticationType == 'sim-otp':
-            nonce = self.request_nonce()
-            command = self.authentication.generate_sim_otp_command(imsi=self.network.imsi,
-                                                                   iccid=self.network.iccid,
-                                                                   nonce=nonce)
-            modem_response = self.network.get_sim_otp_response(command)
-            self.authentication.generate_sim_otp_token(modem_response)
-        elif self.authenticationType == 'totp':
-            self.authentication.credentials['device_id'] = self.network.iccid
-            self.authentication.credentials['private_key'] = self.network.imsi
-
         output = self.authentication.buildPayloadString(message,
                                                         topics=topics,
                                                         modem_type=modem_type,
                                                         modem_id=modem_id,
                                                         version=self.version)
 
         result = super(HologramCloud, self).sendMessage(output, timeout)
+        return self.__parse_result(result)
 
+    def __parse_result(self, result):
         resultList = None
         if self.authenticationType == 'csrpsk':
             resultList = self.__parse_hologram_json_result(result)
@@ -120,8 +116,24 @@ def sendMessage(self, message, topics = None, timeout = 5):
 
         return resultList[0]
 
+    def __populate_totp_credentials(self):
+        try:
+            self.authentication.credentials['device_id'] = self.network.iccid
+            self.authentication.credentials['private_key'] = self.network.imsi
+        except Exception as e:
+            self.logger.error('Unable to fetch device id or private key')
+
+    def __populate_sim_otp_credentials(self):
+        nonce = self.request_nonce()
+        command = self.authentication.generate_sim_otp_command(imsi=self.network.imsi,
+                                                               iccid=self.network.iccid,
+                                                               nonce=nonce)
+        modem_response = self.network.get_sim_otp_response(command)
+        self.authentication.generate_sim_otp_token(modem_response)
+
     def sendSMS(self, destination_number, message):
 
+        self.__enforce_authentication_type_supported()
         self.__enforce_valid_destination_number(destination_number)
         self.__enforce_max_sms_length(message)
 
@@ -206,6 +218,10 @@ def __enforce_valid_destination_number(self, destination_number):
         if not destination_number.startswith('+'):
             raise HologramError('SMS destination number must start with a \'+\' sign')
 
+    def __enforce_authentication_type_supported(self):
+        if self.authenticationType is not 'csrpsk':
+            raise HologramError('%s does not support SDK SMS features' % self.authenticationType)
+
     # REQUIRES: A result code (int).
     # EFFECTS: Returns a translated string based on the given hologram result code.
     def getResultString(self, result_code):