Hologram Python SDK v0.8.2 release

Author: rbalik

CHANGELOG.md

@@ -1,6 +1,24 @@
 # What's New in Hologram Python SDK
 
+## v0.8.2
+
+2018-11-16 Hologram <[email protected]>
+    * Added new commands to control cellular radio: `hologram modem radio-off`
+        and `hologram modem radio-on`
+    * Added new command to restart the modem: `hologram modem reset`
+    * Deprecated `hologram modem connect` and `hologram modem disconnect` in
+        favor of the network versions of those commands. They'll be removed
+        in a future release
+    * Fix issue with auto periodic message sending taking a long time to stop
+        when killed
+    * Fix issue where `hologram network connect` would print that it worked
+        even when it didn't
+    * Fix issue where a zombie pppd process would hang around in the background
+        after a connection failure and tie up a serial port
+    * General code cleanup around the PPP path
+
 ## v0.8.1
+
 2018-09-12 Hologram <[email protected]>
     * Fix issues with PPP (`hologram network connect`) on Nova R410
     * Fix bugs with activating SIM cards via `hologram activate`

Hologram/Cloud.py

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

Hologram/CustomCloud.py

@@ -38,9 +38,12 @@ def __init__(self, credentials, send_host='', send_port=0,
         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
-        self._periodic_msg_enabled = False
+        # We start with the event set, clear it when running and then set when
+        # shutting down. This way, the thread can wait on it and stop immediately
+        # when the script is exiting
+        self._periodic_msg_disabled = threading.Event()
+        self._periodic_msg_disabled.set()
 
         self._receive_buffer_lock = threading.Lock()
         self._receive_cv = threading.Lock()
@@ -158,14 +161,9 @@ def sendPeriodicMessage(self, interval, message, topics=None, timeout=5):
         try:
             self._enforce_minimum_periodic_interval(interval)
 
-            self._periodic_msg_lock.acquire()
-
-            if self._periodic_msg_enabled == True:
+            if not self._periodic_msg_disabled.is_set():
                 raise HologramError('Cannot have more than 1 periodic message job at once')
-
-            self._periodic_msg_enabled = True
-
-            self._periodic_msg_lock.release()
+            self._periodic_msg_disabled.clear()
 
         except Exception as e:
             self.__enforce_network_disconnected()
@@ -186,35 +184,27 @@ def __to_use_at_sockets(self):
     # EFFECTS: This threaded infinite loop shoud keep sending messages with the specified
     #          interval.
     def _periodic_job_thread(self, interval, function, *args):
-        while True:
-            self._periodic_msg_lock.acquire()
-
-            if not self._periodic_msg_enabled:
-                self._periodic_msg_lock.release()
-                break
-
+        while not self._periodic_msg_disabled.is_set():
             self.logger.info('Sending another periodic message...')
             try:
                 response = function(*args)
             except Exception as e:
                 self.logger.info('Message function threw an exception: %s', str(e))
-                self._periodic_msg_lock.release()
                 break
             else:
                 self.logger.info('RESPONSE MESSAGE: %s', self.getResultString(response))
                 if not self.resultWasSuccess(response):
-                    self._periodic_msg_lock.release()
                     break
 
-            self._periodic_msg_lock.release()
-            time.sleep(interval)
+            self._periodic_msg_disabled.wait(interval)
+        self.logger.debug('Periodic job thread stopping')
+        # in case we exited with an exception
+        self._periodic_msg_disabled.set()
 
     def stopPeriodicMessage(self):
         self.logger.info('Stopping periodic job...')
 
-        self._periodic_msg_lock.acquire()
-        self._periodic_msg_enabled = False
-        self._periodic_msg_lock.release()
+        self._periodic_msg_disabled.set()
 
         self._periodic_msg.join()
         self.logger.info('Periodic job stopped')

Hologram/Network/Modem/IModem.py

@@ -61,6 +61,12 @@ def connect(self):
     def disconnect(self):
         raise NotImplementedError('Must instantiate a Modem type')
 
+    def reset(self):
+        raise NotImplementedError('Must instantiate a Modem type')
+
+    def radio_power(self, power_mode):
+        raise NotImplementedError('Must instantiate a Modem type')
+
     def enableSMS(self):
         raise NotImplementedError('Must instantiate a Modem type')
 

Hologram/Network/Modem/Modem.py

@@ -147,7 +147,6 @@ def closeSerialPort(self):
         except Exception:
             self.logger.error('Failed to close serial port')
 
-
     # EFFECTS: backwards compatibility only
     def enableSMS(self):
         self.checkURC()
@@ -235,6 +234,11 @@ def set_network_registration_status(self):
     def reset(self):
         self.set('+CFUN', '16') # restart the modem
 
+    def radio_power(self, power_mode):
+        cfun_val = '1' if power_mode else '0'
+        ok, r = self.command('+CFUN', cfun_val, timeout=5)
+        return ok == ModemResult.OK
+
     def send_message(self, data, timeout=DEFAULT_SEND_TIMEOUT):
 
         self.urc_state = Modem.SOCKET_INIT

Hologram/Network/Modem/ModemMode/PPP.py

@@ -30,7 +30,7 @@ def __init__(self, device_name='/dev/ttyUSB0', all_attached_device_names=[],
         self.route = Route()
         self.all_attached_device_names = all_attached_device_names
         self._ppp = PPPConnection(self.device_name, self.baud_rate, 'noipdefault',
-                                  'usepeerdns', 'defaultroute', 'persist', 'noauth',
+                                  'usepeerdns', 'persist', 'noauth',
                                   connect=self.connect_script)
 
     def isConnected(self):
@@ -44,15 +44,22 @@ def connect(self, timeout=DEFAULT_PPP_TIMEOUT):
 
         result = self._ppp.connect(timeout=timeout)
 
-        if result == True and self.route.wait_for_interface(DEFAULT_PPP_INTERFACE,
-                                                            MAX_PPP_INTERFACE_UP_RETRIES):
+        if result == True:
+            if not self.route.wait_for_interface(DEFAULT_PPP_INTERFACE,
+                                   MAX_PPP_INTERFACE_UP_RETRIES):
+                self.logger.error('Unable to find interface %s. Disconnecting',
+                        DEFAULT_PPP_INTERFACE)
+                self._ppp.disconnect()
+                return False
             return True
         else:
             return False
 
+
     def disconnect(self):
+        self._ppp.disconnect()
         self.__shut_down_existing_ppp_session()
-        return self._ppp.disconnect()
+        return True
 
     # EFFECTS: Makes sure that there are no existing PPP instances on the same
     #          device interface.
@@ -79,7 +86,6 @@ def __check_for_existing_ppp_sessions(self):
         self.logger.info('Checking for existing PPP sessions')
 
         for proc in psutil.process_iter():
-
             try:
                 pinfo = proc.as_dict(attrs=['pid', 'name'])
             except:

Hologram/Network/Modem/ModemMode/pppd.py

@@ -17,6 +17,7 @@
 import threading
 from subprocess import Popen, PIPE, STDOUT
 from Exceptions.HologramError import PPPError, PPPConnectionError
+import errno
 
 __version__ = '1.0.3'
 DEFAULT_CONNECT_TIMEOUT = 200
@@ -29,20 +30,18 @@ def __repr__(self):
     def __init__(self, *args, **kwargs):
         # Logging setup.
         self.logger = logging.getLogger(__name__)
-        self.logger.addHandler(NullHandler())
 
         self._laddr = None
         self._raddr = None
-        self._connectThread = None
-        self._outputRWLock = threading.Condition()
-        self._outputReadyToRead = True
         self.proc = None
 
         self.output = ''
 
         self._commands = []
 
-        if kwargs.pop('sudo', True):
+        # This makes it harder to kill pppd so we're defaulting to it off for now
+        # It's redudant anyway for the CLI
+        if kwargs.pop('sudo', False):
             sudo_path = kwargs.pop('sudo_path', '/usr/bin/sudo')
             if not os.path.isfile(sudo_path) or not os.access(sudo_path, os.X_OK):
                 raise IOError('%s not found' % sudo_path)
@@ -66,73 +65,62 @@ def __init__(self, *args, **kwargs):
     #          Returns true if successful, false otherwise.
     def connect(self, timeout = DEFAULT_CONNECT_TIMEOUT):
 
+        self.logger.info('Starting pppd')
         self.proc = Popen(self._commands, stdout=PIPE, stderr=STDOUT, universal_newlines=True)
 
         # set stdout to non-blocking
         fd = self.proc.stdout.fileno()
         fl = fcntl.fcntl(fd, fcntl.F_GETFL)
         fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
 
-        result = [False]
-
-        self._connectThread = threading.Thread(target = self.connectThreadedFunc,
-                                               args = [result])
-        self._connectThread.daemon = True
-        self._connectThread.start()
-        self._connectThread.join(timeout)
+        result = False
+        try:
+            result = self.waitForPPPSuccess(timeout)
+        except Exception as e:
+            self.logger.error(e)
 
-        # If thread is still alive, tear down pppd connection and kill the thread.
-        if self._connectThread.is_alive():
-            self._connectThread.join(1)
+        if not result and self.proc and (self.proc.poll() is None):
+            self.logger.debug('Killing pppd')
             self.proc.send_signal(signal.SIGTERM)
             time.sleep(1)
 
-        return result[0]
+        return result
+
+
+    def readFromPPP(self):
+        try:
+            self.output += self.proc.stdout.read()
+        except IOError as e:
+            if e.errno != errno.EAGAIN:
+                raise
+            time.sleep(1)
 
-    # EFFECTS: Establish a cellular connection. Returns true if successful,
-    #          false otherwise.
-    def connectThreadedFunc(self, result):
 
-        while True:
-            try:
-                self.output += self.proc.stdout.read()
-            except IOError as e:
-                if e.errno != 11:
-                    raise
-                time.sleep(1)
+    def waitForPPPSuccess(self, timeout):
+        starttime = time.time()
+        while (time.time() - starttime) < timeout:
+            self.readFromPPP()
 
-            if self.laddr != None and self.raddr != None:
-                result[0] = True
-                return
+            if self.laddr is not None and self.raddr is not None:
+                return True
 
             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)
+        return False
 
     # EFFECTS: Disconnects from the network.
-    #          Returns true if successful, false otherwise.
     def disconnect(self):
+        if self.proc and self.proc.poll() is None:
+            self.proc.send_signal(signal.SIGTERM)
+            time.sleep(1)
 
-        try:
-            if not self.connected():
-                return False
-        except PPPConnectionError:
-            return False
-
-        self.proc.send_signal(signal.SIGTERM)
-        time.sleep(1)
-
-        return True
 
     # EFFECTS: Returns true if a cellular connection is established.
     def connected(self):
         if self.proc and self.proc.poll():
-            try:
-                self.output += self.proc.stdout.read()
-            except IOError as e:
-                if e.errno != 11:
-                    raise
+            self.readFromPPP()
             if self.proc.returncode not in [0, 5]:
                 raise PPPConnectionError(self.proc.returncode, self.output)
             return False
@@ -145,11 +133,7 @@ def connected(self):
     @property
     def laddr(self):
         if self.proc and not self._laddr:
-            try:
-                self.output += self.proc.stdout.read()
-            except IOError as e:
-                if e.errno != 11:
-                    raise
+            self.readFromPPP()
             result = re.search(r'local  IP address ([\d\.]+)', self.output)
             if result:
                 self._laddr = result.group(1)
@@ -160,33 +144,10 @@ def laddr(self):
     @property
     def raddr(self):
         if self.proc and not self._raddr:
-            try:
-                self.output += self.proc.stdout.read()
-            except IOError as e:
-                if e.errno != 11:
-                    raise
+            self.readFromPPP()
             result = re.search(r'remote IP address ([\d\.]+)', self.output)
             if result:
                 self._raddr = result.group(1)
 
         return self._raddr
 
-    @property
-    def output(self):
-        self._outputRWLock.acquire()
-
-        while not self._outputReadyToRead:
-            self._outputRWLock.wait()
-
-        self._outputReadyToRead = True
-        self._outputRWLock.release()
-        return self._output
-
-    @output.setter
-    def output(self, output):
-        self._outputReadyToRead = False
-        self._outputRWLock.acquire()
-        self._output = output
-        self._outputReadyToRead = True
-        self._outputRWLock.notifyAll()
-        self._outputRWLock.release()

Hologram/Network/Modem/NovaM.py

@@ -85,3 +85,6 @@ def connect_socket(self, host, port):
             raise NetworkError('Failed to connect socket')
         else:
             self.logger.info('Connect socket is successful')
+
+    def reset(self):
+        self.set('+CFUN', '15') # restart the modem

Hologram/Network/Network.py

@@ -33,6 +33,7 @@ def __init__(self, event=Event()):
 
     def connect(self):
         self.event.broadcast('network.connected')
+        return True
 
     def disconnect(self):
         self.event.broadcast('network.disconnected')

requirements.txt

@@ -10,4 +10,4 @@ python-sdk-auth==0.2.1
 pyudev==0.21.0
 pyusb==1.0.0
 psutil==5.3.1
-requests==2.18.3
+requests==2.20.1