p3lib 1.1.75__tar.gz → 1.1.77__tar.gz

{p3lib-1.1.75 → p3lib-1.1.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p3lib
-Version: 1.1.75
+Version: 1.1.77
 Summary: A group of python modules for networking, plotting data, config storage, automating boot scripts, ssh access and user input output.
 Home-page: https://github.com/pjaos/p3lib
 Author: Paul Austen

{p3lib-1.1.75 → p3lib-1.1.77}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = p3lib
-version = 1.1.75
+version = 1.1.77
 author = Paul Austen
 author_email = pausten.os@gmail.com
 description = A group of python modules for networking, plotting data, config storage, automating boot scripts, ssh access and user input output.

{p3lib-1.1.75 → p3lib-1.1.77}/src/p3lib/boot_manager.py

@@ -3,6 +3,7 @@
 import  os
 import  sys
 import  platform
+import  getpass
 
 from    subprocess import check_call, DEVNULL, STDOUT, Popen, PIPE
 from    datetime import datetime
@@ -35,10 +36,10 @@ class BootManager(object):
         else:
             raise Exception("{} is an unsupported OS.".format(self._osName) )
 
-    def add(self, user, argString=None, enableSyslog=False):
+    def add(self, user=None, argString=None, enableSyslog=False):
         """@brief Add an executable file to the processes started at boot time.
            @param exeFile The file/program to be executed. This should be an absolute path.
-           @param user The user that will run the executable file.
+           @param user The user that will run the executable file. If left as None then the current user will be used.
            @param argString The argument string that the program is to be launched with.
            @param enableSyslog If True enable stdout and stderr to be sent to syslog."""
         if self._platformBootManager:
@@ -63,9 +64,41 @@ class BootManager(object):
 class LinuxBootManager(object):
     """@brief Responsible for adding/removing Linux services using systemd."""
 
-    LOG_PATH="/var/log"
-    SERVICE_FOLDER = "/etc/systemd/system/"
-    SYSTEM_CTL = "/bin/systemctl"
+    LOG_PATH            ="/var/log"
+    ROOT_SERVICE_FOLDER = "/etc/systemd/system/"
+    SYSTEM_CTL_1        = "/bin/systemctl"
+    SYSTEM_CTL_2        = "/usr/bin/systemctl"
+
+    @staticmethod
+    def GetSystemCTLBin():
+        """@brief Get the location of the systemctl binary file on this system.
+           @return The systemctl bin file."""
+        binFile = None
+        if os.path.isfile(LinuxBootManager.SYSTEM_CTL_1):
+            binFile = LinuxBootManager.SYSTEM_CTL_1
+        elif os.path.isfile(LinuxBootManager.SYSTEM_CTL_2):
+            binFile = LinuxBootManager.SYSTEM_CTL_2
+        else:
+            raise Exception("Failed to find the location of the systemctl bin file on this machine.")
+        return binFile
+
+    @staticmethod
+    def GetServiceFolder(rootUser):
+        """"@brief Get the service folder to use.
+            @param rootUser False if non root user.
+            @return The folder that should hold the systemctl service files."""
+        serviceFolder = None
+        if rootUser:
+            serviceFolder = LinuxBootManager.ROOT_SERVICE_FOLDER
+        else:
+            homeFolder = os.path.expanduser('~')
+            serviceFolder = os.path.join(homeFolder, '.config/systemd/user/')
+            if not os.path.isdir(serviceFolder):
+                os.makedirs(serviceFolder)
+
+        if not os.path.isdir(serviceFolder):
+            raise Exception(f"{serviceFolder} folder not found.")
+        return serviceFolder
 
     def __init__(self, uio, allowRootUser):
         """@brief Constructor
@@ -74,12 +107,20 @@ class LinuxBootManager(object):
         self._uio = uio
         self._logFile = None
         self._allowRootUser=allowRootUser
-
-        if os.geteuid() != 0:
-            self._fatalError("Please run this command with root level access.")
-
         self._info("OS: {}".format(platform.system()) )
-
+        self._rootMode = False # If True run as root, else False.
+        self._systemCtlBin = LinuxBootManager.GetSystemCTLBin()
+        if os.geteuid() == 0:
+            if not allowRootUser:
+                self._fatalError(self.__class__.__name__ + f": You are running as root user but allowRootUser={allowRootUser}.")
+            else:
+                self._rootMode = True
+        if not self._rootMode:
+            self._cmdLinePrefix = self._systemCtlBin + " --user"
+        else:
+            self._cmdLinePrefix = self._systemCtlBin
+        self._username = getpass.getuser()
+        self._serviceFolder = LinuxBootManager.GetServiceFolder(self._rootMode)
         self._appName = None
 
     def _getInstallledStartupScript(self):
@@ -188,7 +229,9 @@ class LinuxBootManager(object):
             self._fatalError("{} file not found.".format(absApp) )
 
         appName = appName.replace(".py", "")
-        self._logFile = os.path.join(LinuxBootManager.LOG_PATH, appName)
+        if self._rootMode:
+            # We can only save to /var/log/ is we are root user.
+            self._logFile = os.path.join(LinuxBootManager.LOG_PATH, appName)
 
         return (appName, absApp)
 
@@ -197,7 +240,7 @@ class LinuxBootManager(object):
            @param appName The name of the app to execute.
            @return The absolute path to the service file """
         serviceName = "{}.service".format(appName)
-        serviceFile = os.path.join(LinuxBootManager.SERVICE_FOLDER, serviceName)
+        serviceFile = os.path.join(self._serviceFolder, serviceName)
         return serviceFile
 
     def add(self, user, argString=None, enableSyslog=False):
@@ -209,9 +252,9 @@ class LinuxBootManager(object):
                        to non root user paths on Linux systems and the startup
                        script should then be executed with the same username in
                        order that the same config file is used.
+                       If set to None then the current user is used.
            @param argString The argument string that the program is to be launched with.
            @param enableSyslog If True enable stdout and stderr to be sent to syslog."""
-
         appName, absApp = self._getApp()
 
         serviceFile = self._getServiceFile(appName)
@@ -253,12 +296,12 @@ class LinuxBootManager(object):
         except IOError:
             self._fatalError("Failed to create {}".format(serviceFile) )
 
-        cmd = "{} daemon-reload".format(LinuxBootManager.SYSTEM_CTL)
+        cmd = "{} daemon-reload".format(self._cmdLinePrefix)
         self._runLocalCmd(cmd)
-        cmd = "{} enable {}".format(LinuxBootManager.SYSTEM_CTL, appName)
+        cmd = "{} enable {}".format(self._cmdLinePrefix, appName)
         self._info("Enabled {} on restart".format(appName))
         self._runLocalCmd(cmd)
-        cmd = "{} start {}".format(LinuxBootManager.SYSTEM_CTL, appName)
+        cmd = "{} start {}".format(self._cmdLinePrefix, appName)
         self._runLocalCmd(cmd)
         self._info("Started {}".format(appName))
 
@@ -270,11 +313,11 @@ class LinuxBootManager(object):
 
         serviceFile = self._getServiceFile(appName)
         if os.path.isfile(serviceFile):
-            cmd = "{} disable {}".format(LinuxBootManager.SYSTEM_CTL, appName)
+            cmd = "{} disable {}".format(self._cmdLinePrefix, appName)
             self._runLocalCmd(cmd)
             self._info("Disabled {} on restart".format(appName))
 
-            cmd = "{} stop {}".format(LinuxBootManager.SYSTEM_CTL, appName)
+            cmd = "{} stop {}".format(self._cmdLinePrefix, appName)
             self._runLocalCmd(cmd)
             self._info("Stopped {}".format(appName))
 
@@ -287,11 +330,11 @@ class LinuxBootManager(object):
         """@brief Get a status report.
            @return Lines of text indicating the status of a previously started process."""
         appName, _ = self._getApp()
-        p = Popen([LinuxBootManager.SYSTEM_CTL, 'status', appName], stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        if self._rootMode:
+            p = Popen([self._systemCtlBin, 'status', appName], stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        else:
+            p = Popen([self._systemCtlBin, '--user', 'status', appName], stdin=PIPE, stdout=PIPE, stderr=PIPE)
         output, err = p.communicate(b"input data that is passed to subprocess' stdin")
         response = output.decode() + "\n" + err.decode()
         lines = response.split("\n")
         return lines
-            
-            
-            

{p3lib-1.1.75 → p3lib-1.1.77}/src/p3lib/ngt.py

@@ -114,6 +114,7 @@ class TabbedNiceGui(object):
         self._progressBarStartMessage           = ""
         self._progressBarExpectedMessageList    = []
         self._expectedProgressBarMessageIndex   = 0
+        self._expectedProgressBarMsgCount       = 0
         self._programVersion                    = TabbedNiceGui.GetProgramVersion()
 
         self._logPath           = None
@@ -430,26 +431,39 @@ class TabbedNiceGui(object):
             # Increment the progress bar
             self._progress.set_value( self._progress.value + self._progressStepValue )
 
-    def _startProgress(self, durationSeconds=0, startMessage=None, expectedMsgList=[]):
+    def _startProgress(self, durationSeconds=0, startMessage=None, expectedMsgList=[], expectedMsgCount=0):
         """@brief Start a timer that will update the progress bar.
                   The progress bar can simply update on a timer every second with durationSeconds set to the expected length 
-                  of the task if startMessage is unset and startMessage = None and expectedMessageCount = 0.
+                  of the task.
 
-                  Alternatively if durationSeconds is set and startMessage (expectedMessageCount = 0) is set to some text that
-                  we expect to receive in the log before the progress timer (as detailed above) is triggered.
+                  If startMessage is set to a text string the progress time will not start until the log message area contains 
+                  the start message.
                   
                   Alternatively if expectedMsgList contains a list of strings we expect to receive then the progress bar is 
-                  updated as each message is received. The messages may be the entire line of a log message or parts of a log message line.
+                  updated as each message is received. The messages may be the entire line of a log message or parts of a
+                  log message line.
+
+                  Alternatively if expectedMsgCount is set to a value > 0 then the progress bar is updated as each message is 
+                  added to the log and reaches 100% when the number of messages added to the log file reaches the expectedMsgCount.
+
             @param startMessage The text of the log message we expect to receive to trigger the progress bar timer start.
-            @param expectedMsgList A list of the expected log file messages."""
+            @param expectedMsgList A list of the expected log file messages.
+            @param expectedMsgCount A int value that defines the number of log messages we expect to receive for normal progress
+                                    completion."""
         self._progressValue                     = 0
         self._progressBarStartMessage           = ""
         self._progressBarExpectedMessageList    = []
         self._expectedProgressBarMessageIndex   = 0
+        self._expectedProgressBarMsgCount       = 0
         self._updateProgressOnTimer             = False
         self._progress.set_value( self._progressValue )
+        # If the caller wants to the progress bar to update as the log file message count increases.
+        if expectedMsgCount > 0:
+            self._expectedProgressBarMsgCount = expectedMsgCount
+            self._progressStepValue = TabbedNiceGui.MAX_PROGRESS_VALUE/float(self._expectedProgressBarMsgCount)
+
         # If the caller wants to update the progress bar on expected messages.
-        if len(expectedMsgList):
+        elif len(expectedMsgList):
             #Use the text of log messages to increment the progress bar.
             self._expectedProgressBarMessageIndex = 0
             self._progressBarExpectedMessageList = expectedMsgList
@@ -477,8 +491,13 @@ class TabbedNiceGui(object):
     def _updateProgressBar(self, msg):
         """@brief Update the progress bar if required when a log message is received. This is called as each message is added to the log.
            @param msg The log message received."""
+        # If we update the progress bar as each message is received until we have a log with self._expectedProgressBarMsgCount many messages.
+        if self._expectedProgressBarMsgCount > 0:
+            self._progressValue = self._progressValue + self._progressStepValue
+            self._progress.set_value( self._progressValue )
+            
         # If we have a list of log messages to update the progress bar.
-        if len(self._progressBarExpectedMessageList) > 0:
+        elif len(self._progressBarExpectedMessageList) > 0:
             if self._expectedProgressBarMessageIndex < len(self._progressBarExpectedMessageList):
                 # Get the message we expect to receive next
                 expectedMsg = self._progressBarExpectedMessageList[self._expectedProgressBarMessageIndex]

{p3lib-1.1.75 → p3lib-1.1.77}/src/p3lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: p3lib
-Version: 1.1.75
+Version: 1.1.77
 Summary: A group of python modules for networking, plotting data, config storage, automating boot scripts, ssh access and user input output.
 Home-page: https://github.com/pjaos/p3lib
 Author: Paul Austen