Add Monitoring list / refactor configuration file

glances/core/glances_globals.py

@@ -75,15 +75,20 @@ else:
     locale_dir = None
 gettext.install(gettext_domain, locale_dir)
 
-# Import Glances libs
-from ..core.glances_config import Config as glancesConfig
-from ..core.glances_logs import glancesLogs
-from ..core.glances_monitor_list import monitorList as glancesMonitorList
+# Instances shared between all Glances's scripts
+#===============================================
 
-# Instances shared between all scripts
 # The global instance for the configuration file
+from ..core.glances_config import Config as glancesConfig
 glances_config = glancesConfig()
-# The global instance for the logs
-glances_logs = glancesLogs()
+# Processcount and processlist plugins
+from ..core.glances_processes import glancesProcesses
+glances_processes = glancesProcesses()
+# Default auto process sort is 'cpu_percent'
+process_auto_by = 'cpu_percent'
 # The global instance for the monitored list
+from ..core.glances_monitor_list import monitorList as glancesMonitorList
 glances_monitors = glancesMonitorList(glances_config)
+# The global instance for the logs
+from ..core.glances_logs import glancesLogs
+glances_logs = glancesLogs()

glances/core/glances_limits.py

@@ -183,95 +183,3 @@ class glancesLimits:
 
     def getCritical(self, stat):
         return self.__limits_list[stat][2]
-
-    # TO BE DELETED AFTER THE HTML output refactoring
-    def getSTDCareful(self):
-        return self.getCareful('STD')
-
-    def getSTDWarning(self):
-        return self.getWarning('STD')
-
-    def getSTDCritical(self):
-        return self.getCritical('STD')
-    # /TO BE DELETED AFTER THE HTML output refactoring
-
-    def getCPUCareful(self, stat):
-        return self.getCareful('CPU_' + stat.upper())
-
-    def getCPUWarning(self, stat):
-        return self.getWarning('CPU_' + stat.upper())
-
-    def getCPUCritical(self, stat):
-        return self.getCritical('CPU_' + stat.upper())
-
-    def getLOADCareful(self, core=1):
-        return self.getCareful('LOAD') * core
-
-    def getLOADWarning(self, core=1):
-        return self.getWarning('LOAD') * core
-
-    def getLOADCritical(self, core=1):
-        return self.getCritical('LOAD') * core
-
-    def getMEMCareful(self):
-        return self.getCareful('MEM')
-
-    def getMEMWarning(self):
-        return self.getWarning('MEM')
-
-    def getMEMCritical(self):
-        return self.getCritical('MEM')
-
-    def getSWAPCareful(self):
-        return self.getCareful('SWAP')
-
-    def getSWAPWarning(self):
-        return self.getWarning('SWAP')
-
-    def getSWAPCritical(self):
-        return self.getCritical('SWAP')
-
-    def getTEMPCareful(self):
-        return self.getCareful('TEMP')
-
-    def getTEMPWarning(self):
-        return self.getWarning('TEMP')
-
-    def getTEMPCritical(self):
-        return self.getCritical('TEMP')
-
-    def getHDDTEMPCareful(self):
-        return self.getCareful('HDDTEMP')
-
-    def getHDDTEMPWarning(self):
-        return self.getWarning('HDDTEMP')
-
-    def getHDDTEMPCritical(self):
-        return self.getCritical('HDDTEMP')
-
-    def getFSCareful(self):
-        return self.getCareful('FS')
-
-    def getFSWarning(self):
-        return self.getWarning('FS')
-
-    def getFSCritical(self):
-        return self.getCritical('FS')
-
-    def getProcessCareful(self, stat='', core=1):
-        if stat.upper() != 'CPU':
-            # Use core only for CPU
-            core = 1
-        return self.getCareful('PROCESS_' + stat.upper()) * core
-
-    def getProcessWarning(self, stat='', core=1):
-        if stat.upper() != 'CPU':
-            # Use core only for CPU
-            core = 1
-        return self.getWarning('PROCESS_' + stat.upper()) * core
-
-    def getProcessCritical(self, stat='', core=1):
-        if stat.upper() != 'CPU':
-            # Use core only for CPU
-            core = 1
-        return self.getCritical('PROCESS_' + stat.upper()) * core

glances/core/glances_logs.py

@@ -22,6 +22,10 @@
 import time
 from datetime import datetime
 
+# Import Glances libs
+from glances.core.glances_globals import process_auto_by
+
+
 class glancesLogs:
     """
     Manage logs inside the Glances software
@@ -31,7 +35,10 @@ class glancesLogs:
     item_type = "CPU*|LOAD|MEM|MON"
     item_value = value
     Item is defined by:
-      ["begin", "end", "WARNING|CRITICAL", "CPU|LOAD|MEM",
+      ["begin", 
+       "end", 
+       "WARNING|CRITICAL", 
+       "CPU|LOAD|MEM",
        MAX, AVG, MIN, SUM, COUNT,
        [top3 process list],
        "Processes description"]
@@ -87,26 +94,28 @@ class glancesLogs:
         Else:
           Update the existing item
         """
+
         # Add Top process sort depending on alert type
-        self.sort_process_by = 'none'
+        process_auto_by = 'cpu_percent'
         if (item_type.startswith("MEM")):
             # Sort TOP process by memory_percent
-            self.sort_process_by = 'memory_percent'
+            process_auto_by = 'memory_percent'
         elif (item_type.startswith("CPU IO")):
             # Sort TOP process by io_counters (only for Linux OS)
-            self.sort_process_by = 'io_counters'
+            process_auto_by = 'io_counters'
         elif (item_type.startswith("MON")):
+            # !!! Never in v2 because MON are not logged...
             # Do no sort process for monitored prcesses list
             self.sort_process_by = 'none'
-        else:
-            # Default TOP process sort is cpu_percent
-            self.sort_process_by = 'cpu_percent'
 
         # Sort processes
-        if (self.sort_process_by != 'none'):
-            topprocess = sorted(proc_list, key=lambda process: process[self.sort_process_by],
+        if (process_auto_by != 'none'):
+            # !!! Process list is sorted twise ???
+            # !!! Here and in the processlist plugin
+            topprocess = sorted(proc_list, key=lambda process: process[process_auto_by],
                                 reverse=True)
         else:
+            # !!! Never in v2 because MON are not logged...
             topprocess = proc_list
 
         # Add or update the log

glances/core/glances_monitor_list.py

@@ -20,6 +20,11 @@
 
 # Import system lib
 import subprocess
+import re
+
+# Import Glances lib
+from glances.core.glances_globals import glances_processes
+
 
 class monitorList:
     """
@@ -125,20 +130,21 @@ class monitorList:
         # Iter uppon the monitored list
         for i in range(0, len(self.get())):
             if (self.command(i) is None):
-                # !!! How to get the processes instance ?
-                # !!! Put it on the glances_globals ?
-                # # If there is no command specified in the conf file
-                # # then display CPU and MEM %
-
-                # # Search monitored processes by a regular expression
-                # processlist = processes.getlist()
-                # monitoredlist = [p for p in processlist if re.search(self.regex(i), p['cmdline']) is not None]
-
-                # self.__monitor_list[i]['result'] = "CPU: {0:.1f}% / MEM: {1:.1f}%".format(
-                #                         sum([p['cpu_percent'] for p in monitoredlist]),
-                #                         sum([p['memory_percent'] for p in monitoredlist]))
+                # If there is no command specified in the conf file
+                # then display CPU and MEM %
+
+                # Search monitored processes by a regular expression
+                processlist = glances_processes.getlist()
+                monitoredlist = [p for p in processlist if re.search(self.regex(i), p['cmdline']) is not None]
+
+                self.__monitor_list[i]['count'] = len(monitoredlist)
+                self.__monitor_list[i]['result'] = "CPU: {0:.1f}% | MEM: {1:.1f}%".format(
+                                        sum([p['cpu_percent'] for p in monitoredlist]),
+                                        sum([p['memory_percent'] for p in monitoredlist]))
                 continue
             else:
+                # No process to count
+                self.__monitor_list[i]['count'] = 1
                 # Execute the user command line
                 try:
                     self.__monitor_list[i]['result'] = subprocess.check_output(self.command(i), 

glances/plugins/_processes.py → glances/core/glances_processes.py

@@ -191,8 +191,43 @@ class glancesProcesses:
         return self.processcount
 
 
-    def getlist(self):
-        return self.processlist
+    def getlist(self, sortedby=None):
+        """
+        Return the processlist 
+        """
+        # if (sorted_by is not None):
+        #     # Need to sort ?
+        #     self.processlist = sorted(self.processlist, key=lambda process: process[sorted_by], reverse=True)
+        # return self.processlist
+
+        if (sortedby is None):
+            # No need to sort...
+            return self.processlist
+
+        sortedreverse = True
+        if (sortedby == 'name'):
+            sortedreverse = False
+        
+        if (sortedby == 'io_counters'):
+            # Specific case for io_counters
+            # Sum of io_r + io_w
+            try:
+                # Sort process by IO rate (sum IO read + IO write)
+                listsorted = sorted(self.processlist,
+                                    key=lambda process: process[sortedby][0] -
+                                    process[sortedby][2] + process[sortedby][1] -
+                                    process[sortedby][3], 
+                                    reverse=sortedreverse)
+            except Exception:
+                listsorted = sorted(self.processlist, 
+                                    key=lambda process: process['cpu_percent'],
+                                    reverse=sortedreverse)
+        else:
+            # Others sorts
+            listsorted = sorted(self.processlist, 
+                                key=lambda process: process[sortedby],
+                                reverse=sortedreverse)
+
+        self.processlist = listsorted
 
-# Processcount and processlist plugins
-processes = glancesProcesses()
+        return self.processlist

glances/outputs/glances_curses.py

@@ -196,9 +196,11 @@ class glancesCurses:
         elif self.pressedkey == ord('h'):
             # 'h' > Show/hide help
             self.help_tag = not self.help_tag
-        elif self.pressedkey == ord('i') and psutil_get_io_counter_tag:
+        elif self.pressedkey == ord('i'):
+        # elif self.pressedkey == ord('i') and psutil_get_io_counter_tag:
+            # !!! Manage IORate (non existing) on Mac OS
             # 'i' > Sort processes by IO rate (not available on OS X)
-            self.args.process_sorted_by = 'io_counter'
+            self.args.process_sorted_by = 'io_counters'
         elif self.pressedkey == ord('l'):
             # 'l' > Show/hide log messages
             self.log_tag = not self.log_tag

glances/plugins/glances_alert.py

@@ -50,8 +50,9 @@ class Plugin(GlancesPlugin):
         """
         Nothing to do here
         Just return the global glances_log
-        """
+        """        
 
+        # Set the stats to the glances_logs
         self.stats = glances_logs.get()
 
 
@@ -78,7 +79,7 @@ class Plugin(GlancesPlugin):
                 msg = " {0}".format(_("(one entry)"))
             ret.append(self.curse_add_line(msg, "TITLE"))
             # Loop over alerts
-            for alert in glances_logs.get():
+            for alert in self.stats:
                 # New line
                 ret.append(self.curse_new_line())
                 # Start

glances/plugins/glances_monitor.py

@@ -65,6 +65,24 @@ class Plugin(GlancesPlugin):
         return self.stats
 
 
+    def get_alert(self, nbprocess=0, countmin=None, countmax=None):
+        # Return the alert status relative to the process number
+        if (countmin is None):
+            countmin = nbprocess
+        if (countmax is None):
+            countmax = nbprocess
+        if (nbprocess > 0):
+            if (int(countmin) <= int(nbprocess) <= int(countmax)):
+                return 'OK'
+            else:
+                return 'WARNING'
+        else:
+            if (int(countmin) == 0):
+                return 'OK'
+            else:
+                return 'CRITICAL'
+
+
     def msg_curse(self, args=None):
         """
         Return the dict to display in the curse interface
@@ -73,12 +91,22 @@ class Plugin(GlancesPlugin):
         ret = []
 
         # Build the string message
-        if (self.stats != []):
-            msg = "{0}".format(_("Monitored list"))
-            ret.append(self.curse_add_line(msg, "TITLE"))
-            for m in self.stats:
-                ret.append(self.curse_new_line())
-                msg = "{0}".format(str(m))
-                ret.append(self.curse_add_line(msg))
-
+        for m in self.stats:
+            msg = "{0:<16} ".format(str(m['description']))
+            ret.append(self.curse_add_line(msg, 
+                self.get_alert(m['count'], m['countmin'], m['countmax'])))
+            msg = "{0:<3} ".format(m['count'] if (m['count'] > 1) else "")
+            ret.append(self.curse_add_line(msg))
+            msg = "{0:13} ".format(_("RUNNING") if (m['count'] >= 1) else _("NOT RUNNING"))
+            ret.append(self.curse_add_line(msg))
+            msg = "{0}".format(m['result'] if (m['count'] >= 1) else "")
+            ret.append(self.curse_add_line(msg))
+            ret.append(self.curse_new_line())
+
+        # Delete the last empty line
+        try:
+            ret.pop()
+        except IndexError:
+            pass
+            
         return ret

glances/plugins/glances_plugin.py

@@ -99,6 +99,8 @@ class GlancesPlugin(object):
             value = (current * 100) / max
         except ZeroDivisionError:
             return 'DEFAULT'
+        except TypeError:
+            return 'DEFAULT'
 
         # Manage limits
         ret = 'OK'

glances/plugins/glances_processcount.py

@@ -19,7 +19,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 from glances_plugin import GlancesPlugin
-from _processes import processes
+from glances.core.glances_globals import glances_processes, process_auto_by
 
 
 class Plugin(GlancesPlugin):
@@ -51,9 +51,9 @@ class Plugin(GlancesPlugin):
         """
 
         # Here, update is call for processcount AND processlist
-        processes.update()
+        glances_processes.update()
 
-        self.stats = processes.getcount()
+        self.stats = glances_processes.getcount()
 
 
     def msg_curse(self, args=None):
@@ -93,9 +93,12 @@ class Plugin(GlancesPlugin):
         # Display sort information
         if (args.process_sorted_by == 'auto'):
             msg = "{0}".format(_("sorted automatically"))
+            ret.append(self.curse_add_line(msg))
+            msg = " {0} {1}".format(_("by"), process_auto_by)
+            ret.append(self.curse_add_line(msg))
         else:
-            msg = "{0}".format(_("sorted by ") + args.process_sorted_by)
-        ret.append(self.curse_add_line(msg, 'UNDERLINE'))
+            msg = "{0} {1}".format(_("sorted by"), args.process_sorted_by)
+            ret.append(self.curse_add_line(msg))
 
         # Return the message with decoration 
         return ret

glances/plugins/glances_processlist.py

@@ -21,7 +21,7 @@
 from datetime import timedelta
 
 from glances_plugin import GlancesPlugin
-from _processes import processes
+from glances.core.glances_globals import glances_processes, process_auto_by
 
 
 class Plugin(GlancesPlugin):
@@ -45,7 +45,7 @@ class Plugin(GlancesPlugin):
 
         # Note: Update is done in the processcount plugin
 
-        self.stats = processes.getlist()
+        self.stats = glances_processes.getlist()
         # We want to display the stat in the curse interface
         self.display_curse = True
         # Set the message position
@@ -64,13 +64,20 @@ class Plugin(GlancesPlugin):
         # Init the return message
         ret = []
 
+        # Compute the sort key
+        if (args.process_sorted_by == 'auto'):
+            process_sort_key = process_auto_by
+        else:
+            process_sort_key = args.process_sorted_by
+        sort_style = 'BOLD'
+
         # Header
         msg="{0:15}".format(_(""))
         ret.append(self.curse_add_line(msg))
         msg="{0:>6}".format(_("CPU%"))
-        ret.append(self.curse_add_line(msg))
+        ret.append(self.curse_add_line(msg, sort_style if process_sort_key == 'cpu_percent' else 'DEFAULT'))
         msg="{0:>6}".format(_("MEM%"))
-        ret.append(self.curse_add_line(msg))
+        ret.append(self.curse_add_line(msg, sort_style if process_sort_key == 'memory_percent' else 'DEFAULT'))
         msg="{0:>6}".format(_("VIRT"))
         ret.append(self.curse_add_line(msg, optional=True))
         msg="{0:>6}".format(_("RES"))
@@ -86,17 +93,17 @@ class Plugin(GlancesPlugin):
         msg="{0:>9}".format(_("TIME+"))
         ret.append(self.curse_add_line(msg, optional=True))
         msg="{0:>6}".format(_("IOr/s"))
-        ret.append(self.curse_add_line(msg, optional=True))
+        ret.append(self.curse_add_line(msg, sort_style if process_sort_key == 'io_counters' else 'DEFAULT', optional=True))
         msg="{0:>6}".format(_("IOw/s"))
-        ret.append(self.curse_add_line(msg, optional=True))
+        ret.append(self.curse_add_line(msg, sort_style if process_sort_key == 'io_counters' else 'DEFAULT', optional=True))
         msg=" {0:8}".format(_("Command"))
         ret.append(self.curse_add_line(msg, optional=True))
  
         # Trying to display proc time
         tag_proc_time = True
 
-        # Loop over processes (sorted by args.process_sorted_by)
-        for p in sorted(self.stats, key=lambda process: process['cpu_percent'], reverse=True):
+        # Loop over processes (sorted by the sort key previously compute)
+        for p in glances_processes.getlist(process_sort_key):
             ret.append(self.curse_new_line())
             # Name
             msg="{0:15}".format(p['name'][:15])
@@ -146,12 +153,19 @@ class Plugin(GlancesPlugin):
             ret.append(self.curse_add_line(msg, optional=True))
             # IO read
             io_rs = (p['io_counters'][0] - p['io_counters'][2]) / p['time_since_update']
-            msg = "{0:>6}".format(self.auto_unit(io_rs, low_precision=False))
+            if (io_rs == 0):
+                msg ="{0:>6}".format("0")
+            else:
+                msg = "{0:>6}".format(self.auto_unit(io_rs, low_precision=False))
             ret.append(self.curse_add_line(msg, optional=True))
             # IO write
             io_ws = (p['io_counters'][1] - p['io_counters'][3]) / p['time_since_update']
-            msg = "{0:>6}".format(self.auto_unit(io_ws, low_precision=False))
+            if (io_ws == 0):
+                msg ="{0:>6}".format("0")
+            else:
+                msg = "{0:>6}".format(self.auto_unit(io_ws, low_precision=False))
             ret.append(self.curse_add_line(msg, optional=True))
+            # Command line
             msg = " {0}".format(p['cmdline'])
             ret.append(self.curse_add_line(msg, optional=True))