Hologram Python SDK v0.6.1 release

Author: tzhenghao

ChangeLog

@@ -1,3 +1,10 @@
+2017-09-29 Hologram <[email protected]>
+    * Fixed bug where empty result list might cause an index error
+
+2017-09-28 Hologram <[email protected]>
+    * Logging is now turned off by default for CLI subcommands.
+    * Added -v and -vv options for INFO and DEBUG log levels respectively.
+
 2017-09-22 Hologram <[email protected]>
     * Added program install verification steps to install script.
 

Hologram/Authentication/CSRPSKAuthentication.py

@@ -9,7 +9,6 @@
 # LICENSE: Distributed under the terms of the MIT License
 #
 import json
-import sys
 from Exceptions.HologramError import AuthenticationError
 from HologramAuthentication import HologramAuthentication
 
@@ -24,11 +23,7 @@ def __init__(self, credentials):
     def buildPayloadString(self, messages, topics=None, modem_type=None,
                            modem_id=None, version=None):
 
-        try:
-            self.enforceValidDeviceKey()
-        except AuthenticationError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        self.enforceValidDeviceKey()
 
         super(CSRPSKAuthentication, self).buildPayloadString(messages,
                                                              topics=topics,
@@ -40,11 +35,7 @@ def buildPayloadString(self, messages, topics=None, modem_type=None,
 
     def buildSMSPayloadString(self, destination_number, message):
 
-        try:
-            self.enforceValidDeviceKey()
-        except AuthenticationError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        self.enforceValidDeviceKey()
 
         send_data = 'S' + self.credentials['devicekey']
         send_data += destination_number + ' ' + message

Hologram/Cloud.py

@@ -9,12 +9,11 @@
 
 import logging
 from logging import NullHandler
-import sys
 import Event
 from Network import NetworkManager
 from Authentication import *
 
-__version__ = '0.6.0'
+__version__ = '0.6.1'
 
 class Cloud(object):
 
@@ -113,8 +112,7 @@ def send_port(self, send_port):
         try:
             self._send_port = int(send_port)
         except ValueError as e:
-            self.logger.error('Invalid port parameter. Unable to convert port to a valid integer')
-            sys.exit(1)
+            raise ValueError('Invalid port parameter. Unable to convert port to a valid integer')
 
     @property
     def receive_host(self):

Hologram/CustomCloud.py

@@ -34,14 +34,9 @@ def __init__(self, credentials, send_host='', send_port=0,
                                           receive_port=receive_port,
                                           network=network)
 
-        try:
-            # Enforce that the send and receive configs are set before using the class.
-            if enable_inbound and (receive_host == '' or receive_port == 0):
-                raise HologramError('Must set receive host and port for inbound connection')
-
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        # Enforce that the send and receive configs are set before using the class.
+        if enable_inbound and (receive_host == '' or receive_port == 0):
+            raise HologramError('Must set receive host and port for inbound connection')
 
         self._periodic_msg_lock = threading.Lock()
         self._periodic_msg = None
@@ -81,14 +76,15 @@ def sendMessage(self, message, timeout=SEND_TIMEOUT):
 
             self.event.broadcast('message.sent')
             return resultbuf
-
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
         except (IOError):
+            self.__enforce_network_disconnected()
             self.logger.error('An error occurred while attempting to send the message to the cloud')
             self.logger.error('Please try again.')
             return ''
+        except Exception as e:
+            self.__enforce_network_disconnected()
+            raise
+
 
     def open_send_socket(self, timeout=SEND_TIMEOUT):
 
@@ -104,10 +100,6 @@ def open_send_socket(self, timeout=SEND_TIMEOUT):
             self.sock.settimeout(timeout)
             self.sock.connect((self.send_host, self.send_port))
             self._is_send_socket_open = True
-
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
         except (IOError):
             self.logger.error('An error occurred while attempting to send the message to the cloud')
             self.logger.error('Please try again.')
@@ -123,10 +115,6 @@ def close_send_socket(self):
             self.sock.close()
             self._is_send_socket_open = False
             self.logger.info('Socket closed.')
-
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
         except (IOError):
             self.logger.error('An error occurred while attempting to send the message to the cloud')
             self.logger.error('Please try again.')
@@ -152,22 +140,19 @@ def sendPeriodicMessage(self, interval, message, topics=None, timeout=5):
 
         try:
             self._enforce_minimum_periodic_interval(interval)
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
 
-        self._periodic_msg_lock.acquire()
+            self._periodic_msg_lock.acquire()
 
-        try:
             if self._periodic_msg_enabled == True:
                 raise HologramError('Cannot have more than 1 periodic message job at once')
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
 
-        self._periodic_msg_enabled = True
+            self._periodic_msg_enabled = True
 
-        self._periodic_msg_lock.release()
+            self._periodic_msg_lock.release()
+
+        except Exception as e:
+            self.__enforce_network_disconnected()
+            raise
 
         self._periodic_msg = threading.Thread(target=self._periodic_job_thread,
                                               args=[interval, self.sendMessage,
@@ -211,11 +196,7 @@ def initializeReceiveSocket(self):
 
     def openReceiveSocket(self):
 
-        try:
-            self.__enforce_receive_host_and_port()
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        self.__enforce_receive_host_and_port()
 
         self._receive_cv.acquire()
         self._receive_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -258,7 +239,7 @@ def open_receive_socket_helper(self):
         self._receive_cv.release()
 
         # Spin a new thread for accepting incoming operations
-        self._accept_thread = threading.Thread(target = self.acceptIncomingConnection)
+        self._accept_thread = threading.Thread(target=self.acceptIncomingConnection)
         self._accept_thread.daemon = True
         self._accept_thread.start()
 
@@ -297,7 +278,7 @@ def acceptIncomingConnection(self):
             try:
                 self._receive_socket.setblocking(0)
                 (clientsocket, address) = self._receive_socket.accept()
-                self.logger.info('Connected to ' + str(address))
+                self.logger.info('Connected to %s', address)
                 # Spin a new thread to handle the current incoming operation.
                 threading.Thread(target = self.__incoming_connection_thread,
                                  args = [clientsocket]).start()
@@ -324,13 +305,13 @@ def __incoming_connection_thread(self, clientsocket):
                 break
             recv += result
 
-        self.logger.info('Received message: ' + str(recv))
+        self.logger.info('Received message: %s', recv)
 
         self._receive_buffer_lock.acquire()
 
         # Append received message into receive buffer
         self._receive_buffer.append(recv)
-        self.logger.debug('Receive buffer: ' + str(self._receive_buffer))
+        self.logger.debug('Receive buffer: %s', self._receive_buffer)
 
         self._receive_buffer_lock.release()
 
@@ -364,3 +345,7 @@ def __enforce_receive_host_and_port(self):
     def _enforce_minimum_periodic_interval(self, interval):
         if interval < MIN_PERIODIC_INTERVAL:
             raise HologramError('Interval cannot be less than %d seconds.' % MIN_PERIODIC_INTERVAL)
+
+    def __enforce_network_disconnected(self):
+        if self.network_type == 'Cellular':
+            self.network.disconnect()

Hologram/HologramCloud.py

@@ -58,7 +58,7 @@ class HologramCloud(CustomCloud):
     }
 
     def __init__(self, credentials, enable_inbound=False, network='',
-                 authentication_type='csrpsk'):
+                 authentication_type='totp'):
         super(HologramCloud, self).__init__(credentials,
                                             send_host=HOLOGRAM_HOST_SEND,
                                             send_port=HOLOGRAM_PORT_SEND,
@@ -72,16 +72,12 @@ def __init__(self, credentials, enable_inbound=False, network='',
     # EFFECTS: Authentication Configuration
     def setAuthenticationType(self, credentials, authentication_type='csrpsk'):
 
-        try:
-            if authentication_type not in HologramCloud._authentication_handlers:
-                raise HologramError('Invalid authentication type: %s' % authentication_type)
+        if authentication_type not in HologramCloud._authentication_handlers:
+            raise HologramError('Invalid authentication type: %s' % authentication_type)
 
-            self.authenticationType = authentication_type
+        self.authenticationType = authentication_type
 
-            self.authentication = HologramCloud._authentication_handlers[self.authenticationType](credentials)
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        self.authentication = HologramCloud._authentication_handlers[self.authenticationType](credentials)
 
     # EFFECTS: Sends the message to the cloud.
     def sendMessage(self, message, topics = None, timeout = 5):
@@ -126,12 +122,8 @@ def sendMessage(self, message, topics = None, timeout = 5):
 
     def sendSMS(self, destination_number, message):
 
-        try:
-            self.__enforce_valid_destination_number(destination_number)
-            self.__enforce_max_sms_length(message)
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        self.__enforce_valid_destination_number(destination_number)
+        self.__enforce_max_sms_length(message)
 
         output = self.authentication.buildSMSPayloadString(destination_number,
                                                            message)
@@ -148,26 +140,21 @@ def sendSMS(self, destination_number, message):
     # EFFECTS: Request for nonce.
     def request_nonce(self):
 
-        try:
-            self.open_send_socket()
-
-            # build nonce request payload string
-            request = self.authentication.buildNonceRequestPayloadString()
+        self.open_send_socket()
 
-            self.logger.debug("Sending nonce request with body of length %d", len(request))
-            self.logger.debug('Send: %s', request)
+        # build nonce request payload string
+        request = self.authentication.buildNonceRequestPayloadString()
 
-            self.sock.send(request)
-            self.logger.debug('Nonce request sent.')
+        self.logger.debug("Sending nonce request with body of length %d", len(request))
+        self.logger.debug('Send: %s', request)
 
-            resultbuf = binascii.b2a_hex(self.receive_send_socket(max_receive_bytes=32))
+        self.sock.send(request)
+        self.logger.debug('Nonce request sent.')
 
-            if resultbuf is None:
-                raise HologramError('Internal nonce error')
+        resultbuf = binascii.b2a_hex(self.receive_send_socket(max_receive_bytes=32))
 
-        except HologramError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        if resultbuf is None:
+            raise HologramError('Internal nonce error')
 
         return resultbuf
 
@@ -206,6 +193,9 @@ def __parse_hologram_compact_result(self, result):
                 self.logger.error('Server replied with invalid JSON [%s]', result)
                 resultList = [ERR_UNKNOWN]
 
+        if len(resultList) == 0:
+            resultList = [ERR_UNKNOWN]
+
         return resultList
 
     def __enforce_max_sms_length(self, message):

Hologram/Network/Cellular.py

@@ -16,7 +16,6 @@
 from Modem import MS2131
 from Network import Network
 import subprocess
-import sys
 import usb.core
 
 # Cellular return codes.
@@ -141,15 +140,10 @@ def modem(self):
 
     @modem.setter
     def modem(self, modem):
-        try:
-            if modem not in self._modemHandlers:
-                raise NetworkError('Invalid modem type: %s' % modem)
-            else:
-                self._modem = self._modemHandlers[modem](event=self.event)
-            # not sure about the exception handling in here. seems like we should let it bubble up
-        except NetworkError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        if modem not in self._modemHandlers:
+            raise NetworkError('Invalid modem type: %s' % modem)
+        else:
+            self._modem = self._modemHandlers[modem](event=self.event)
 
     @property
     def localIPAddress(self):

Hologram/Network/Modem/ModemMode/PPP.py

@@ -9,7 +9,6 @@
 #
 import psutil
 import subprocess
-import sys
 import time
 from pppd import PPPConnection
 from IPPP import IPPP
@@ -40,11 +39,7 @@ def isConnected(self):
     #          reroute packets to ppp0 interface.
     def connect(self, timeout=DEFAULT_PPP_TIMEOUT):
 
-        try:
-            self.__enforce_no_existing_ppp_session()
-        except PPPError as e:
-            self.logger.error(repr(e))
-            sys.exit(1)
+        self.__enforce_no_existing_ppp_session()
 
         result = self._ppp.connect(timeout=timeout)
 

Hologram/Network/Modem/ModemMode/pppd.py

@@ -13,7 +13,6 @@
 import os
 import re
 import signal
-import sys
 import time
 import threading
 from subprocess import Popen, PIPE, STDOUT
@@ -106,14 +105,10 @@ def connectThreadedFunc(self, result):
                 result[0] = True
                 return
 
-            try:
-                if 'Modem hangup' in self.output:
-                    raise PPPError('Modem hangup - possibly due to an unregistered SIM')
-                elif self.proc.poll():
-                    raise PPPConnectionError(self.proc.returncode, self.output)
-            except (PPPError, PPPConnectionError) as e:
-                self.logger.error(repr(e))
-                sys.exit(1)
+            if 'Modem hangup' in self.output:
+                raise PPPError('Modem hangup - possibly due to an unregistered SIM')
+            elif self.proc.poll():
+                raise PPPConnectionError(self.proc.returncode, self.output)
 
     # EFFECTS: Disconnects from the network.
     #          Returns true if successful, false otherwise.