Ticket #2141: cpu-and-memory-resource-indicator.patch

extensions/deviceicon/Makefile.am

@@ -4 +4 @@
         __init__.py     \
         battery.py      \
         network.py      \
+        resources.py    \
         speaker.py      \
         volume.py

new file extensions/deviceicon/resources.py

@@ +1 @@
+# Copyright (C) Anish Mangal <anishmangal2002@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+from gettext import gettext as _
+import logging
+import os
+
+import gobject
+import gtk
+import gconf
+
+from sugar.graphics.tray import TrayIcon
+from sugar.graphics.xocolor import XoColor
+from sugar.graphics.palette import Palette
+from sugar.graphics import style
+
+_SYSTEM_MOOD_HAPPY = '-happy'
+_SYSTEM_MOOD_NORMAL = '-normal'
+_SYSTEM_MOOD_SAD = '-sad'
+_SYSTEM_MOOD_ERROR = '-error'
+
+_ICON_NAME = 'computer'
+
+class DeviceView(TrayIcon):
+
+    FRAME_POSITION_RELATIVE = 500
+
+    def __init__(self):
+        client = gconf.client_get_default()
+        self._model = ResourceModel()
+        self._color = XoColor(client.get_string('/desktop/sugar/user/color'))
+        TrayIcon.__init__(self, icon_name=_ICON_NAME, xo_color=self._color)
+        self._model.connect('system-mood-changed',
+                self.__system_mood_changed_cb)
+        self.create_palette()
+
+    def create_palette(self):
+        self.palette = ResourcePalette(_('System resources'),
+                self._model)
+        self.palette.set_group_id('frame')
+        return self.palette
+
+    def __system_mood_changed_cb(self, gobject, mood):
+        self.icon.props.icon_name = _ICON_NAME + mood
+
+class ResourcePalette(Palette):
+
+    def __init__(self, primary_text, model):
+        Palette.__init__(self, label=primary_text)
+
+        self._vbox = gtk.VBox()
+        self.set_content(self._vbox)
+
+        self._cpu_text = gtk.Label()
+        self._vbox.pack_start(self._cpu_text, padding=style.DEFAULT_PADDING)
+        self._cpu_bar = gtk.ProgressBar()
+        self._cpu_bar.set_size_request(
+            style.zoom(style.GRID_CELL_SIZE * 4), -1)
+        self._vbox.pack_start(self._cpu_bar, padding=style.DEFAULT_PADDING)
+
+        self._memory_text = gtk.Label()
+        self._vbox.pack_start(self._memory_text, padding=style.DEFAULT_PADDING)
+        self._memory_bar = gtk.ProgressBar()
+        self._memory_bar.set_size_request(
+            style.zoom(style.GRID_CELL_SIZE * 4), -1)
+        self._vbox.pack_start(self._memory_bar, padding=style.DEFAULT_PADDING)
+
+        model.connect('resource-status-updated',
+            self.__resource_status_updated_cb)
+        model.connect('resource-compute-error',
+            self.__resource_compute_error_cb)
+
+        self._vbox.show()
+        self._cpu_text.show()
+        self._cpu_bar.show()
+        self._memory_text.show()
+        self._memory_bar.show()
+
+    def __resource_status_updated_cb(self, gobject, cpu_in_use,
+            memory_in_use):
+        self._cpu_text.set_label(_('CPU in use: %d%%') % cpu_in_use)
+        self._cpu_bar.set_fraction(cpu_in_use / 100.0)
+        self._memory_text.set_label(_('Memory in use: %d%%') %
+            memory_in_use)
+        self._memory_bar.set_fraction(memory_in_use / 100.0)
+
+    def __resource_compute_error_cb(self, gobject):
+        """
+        Display and error message since we've hit an exception.
+
+        """
+        # Use the existing _cpu_text label to display the error. Remove
+        # everything else.
+        self._cpu_text.set_size_request(
+            style.zoom(style.GRID_CELL_SIZE * 4), -1)
+        self._cpu_text.set_line_wrap(True)
+        self._cpu_text.set_text(_('Cannot compute CPU and memory usage '
+            'statistics!'))
+        self._vbox.remove(self._cpu_bar)
+        self._vbox.remove(self._memory_text)
+        self._vbox.remove(self._memory_bar)
+
+class ResourceModel(gobject.GObject):
+    __gsignals__ = {
+        'system-mood-changed': (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE,
+                           ([str])),
+        'resource-status-updated': (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE,
+                           ([int, int])),
+        'resource-compute-error': (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE,
+                           ([]))
+    }
+
+    def __init__(self):
+        gobject.GObject.__init__(self)
+        self._system_mood = ''
+        try:
+            self._cpu_times = self._get_cpu_times_list()
+        except IOError:
+            logging.exception('An error ocurred while attempting to '
+                'read /proc/stat')
+            self.emit('resource-compute-error')
+        self._timer = gobject.timeout_add(5000, self.__timer_cb)
+
+    def __timer_cb(self):
+        try:
+            cpu_in_use = 100 - self._percentage_cpu_available()
+            memory_in_use = 100 - self._percentage_memory_available()
+        except IOError:
+            logging.exception('An error ocurred while trying to '
+                'retrieve resource usage statistics')
+            system_mood = _SYSTEM_MOOD_ERROR
+            self.emit('system-mood-changed', system_mood)
+            self.emit('resource-compute-error')
+            return False
+        else:
+            self.emit('resource-status-updated', cpu_in_use,
+                    memory_in_use)
+
+            total_load = (cpu_in_use + memory_in_use)
+            if total_load >= 0 and total_load <= 67:
+                system_mood = _SYSTEM_MOOD_HAPPY
+            elif total_load > 67 and total_load <= 133:
+                system_mood = _SYSTEM_MOOD_NORMAL
+            elif total_load > 133 and total_load <=200:
+                system_mood = _SYSTEM_MOOD_SAD
+            else:
+                # This should never happen
+                system_mood = _SYSTEM_MOOD_ERROR
+                logging.error('Computed system load out of range!')
+                self.emit('system-mood-changed', system_mood)
+                self.emit('resource-compute-error')
+                return False
+
+            # Update the frame icon only when system mood changes
+            if self._system_mood != system_mood:
+                self._system_mood = system_mood
+                self.emit('system-mood-changed', system_mood)
+
+            return True
+
+    def _get_cpu_times_list(self):
+        """Return various cpu times as read from /proc/stat
+
+        This method returns the following cpu times measured
+        in jiffies (1/100 of a second for x86 systems)
+        as an ordered list of numbers - [user, nice,
+        system, idle, iowait] where,
+
+        user: normal processes executing in user mode
+        nice: niced processes executing in user mode
+        system: processes executing in kernel mode
+        idle: twiddling thumbs
+        iowait: waiting for I/O to complete
+
+        Note: For systems having 2 or more CPU's, the above
+        numbers would be the cumulative sum of these times
+        for all CPU's present in the system.
+
+        """
+        user, nice, system, idle, iowait = \
+                file('/proc/stat').readline().split()[1:6]
+        return [int(user), int(nice), int(system), int(idle),
+                int(iowait)]
+
+    def _percentage_cpu_available(self):
+        """
+        Return free CPU resources as a percentage
+
+        """
+        cpu_times_new = self._get_cpu_times_list()
+        cpu_times_current = []
+        for i in range(len(cpu_times_new)):
+            cpu_times_current.append(cpu_times_new[i] - \
+                    self._cpu_times[i])
+
+        user, nice, system, idle, iowait = cpu_times_current
+        cpu_free = (idle + iowait) * 100.0 / sum(cpu_times_current)
+        self._cpu_times = self._get_cpu_times_list()
+        return cpu_free
+
+    def _percentage_memory_available(self):
+        """
+        Return free memory as a percentage
+
+        """
+        for line in file('/proc/meminfo'):
+            name, value, unit = line.split()[:3]
+            if 'MemTotal:' == name:
+                total = int(value)
+            elif 'MemFree:' == name:
+                free = int(value)
+            elif 'Buffers:' == name:
+                buffers = int(value)
+            elif 'Cached:' == name:
+                cached = int(value)
+            elif 'Active:' == name:
+                break
+        return (free + buffers + cached) * 100.0 / total
+
+def setup(tray):
+    if not (os.path.exists('/proc/stat') and os.path.exists('/proc/meminfo')):
+        logging.warning('Either /proc/stat or /proc/meminfo not present. Not '
+            'adding the CPU and memory usage icon to the frame')
+        return
+    tray.add_device(DeviceView())