From b7ba754307c12da37c836dff667d6faf25293046 Mon Sep 17 00:00:00 2001
From: Eugeni Dodonov <eugeni@mandriva.com>
Date: Tue, 22 Sep 2009 20:36:46 -0300
Subject: imported

---
 net_monitor.py | 481 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 481 insertions(+)
 create mode 100755 net_monitor.py

(limited to 'net_monitor.py')

diff --git a/net_monitor.py b/net_monitor.py
new file mode 100755
index 0000000..c1f699f
--- /dev/null
+++ b/net_monitor.py
@@ -0,0 +1,481 @@
+#!/usr/bin/python
+
+import gobject
+import gtk
+import pango
+
+import gc
+import os
+from stat import *
+import datetime
+import getopt
+import sys
+import traceback
+
+from threading import Thread
+from Queue import Queue
+import time
+
+import textwrap
+
+# localization
+import gettext
+try:
+    gettext.install("msec")
+except IOError:
+    _ = str
+
+ifaces = {}
+HISTOGRAM_SIZE=50
+
+def readnet():
+    """Reads values from /proc/net/dev"""
+    net = {}
+    data = open("/proc/net/dev").readlines()[2:]
+    for l in data:
+        dev, vals = l.split(":")
+        dev = dev.strip()
+        vals = vals.split()
+        net[dev] = vals
+    return net
+
+def get_traffic(iface):
+    net = readnet()
+    if iface in net:
+        bytes_in = int(net[iface][0])
+        bytes_out = int(net[iface][8])
+    else:
+        bytes_in = 0
+        bytes_out = 0
+    return bytes_in, bytes_out
+
+def format_size(size):
+    """Pretty-Formats size"""
+    return size
+
+# borrowed from gnome-network-monitor 0.9.1 (gnetworkmonitor.sourceforge.net)
+class LoadGraph:
+    """
+    This class is able do display a nicely formatted graph if interface
+    bandwidth load.
+    """
+    # we don't want to allow the window to shrink below this height
+    min_height = 70 
+    padding = { "left" : 50, "right" : 10, "top" : 10, "bottom" : 10 }
+    colors  = ( "bg", "bg_outer", "in", "out" )
+
+    def __init__(self, widget, hist, size):
+        """
+        widget   => GtkDrawingArea we paint into
+        hist     => a list of integers containing the hist of incoming traffic
+        width, height => initial size of the GtkDrawingArea widget
+        """
+        # set the minimum height of the widget
+        widget.set_size_request(-1, 70)
+
+        # the object holding the history and its size
+        self.__hist = hist
+        self.__size = size
+
+        # strings holding 0, middle and max values for displayed graph
+        self.__str_min = "0"
+        self.__str_mid = ""     # gets computed later
+        self.__str_max = ""     # gets computer later
+
+        # size of the GtkDrawingArea
+        self.__rect = self.__inner = gtk.gdk.Rectangle()
+        self.maxval = 0                     # maximum value in the history
+        self.__mesh_x = self.__mesh_y = 0   # distance in pixels between items
+        self.__get_max()
+        self.__on_size(widget.get_allocation())
+
+        # save reference to the widget we paint into
+        self.__widget = widget
+
+        # lists holding bandwidth history mapped to actual coordinates
+        self.__in  = list()
+        self.__out = list()
+
+        self.__colors = dict()
+        self.set_color(bg=(0, 0, 0), fg_in=(255, 0, 0), fg_out=(0, 255, 0))
+        self.__context = None
+
+    def __set_context_color(self, con, col_tuple):
+        """ Cleaner might be to extend the context class, but who cares?  """
+        con.set_source_rgb(col_tuple[0], col_tuple[1], col_tuple[2])
+
+    def __draw(self):
+        """ Strokes the rectangles and draws the curves """
+        if (self.__context == None):
+            return
+        # stroke the outer rectangle
+        self.__context.rectangle(0, 0, self.__rect.width, self.__rect.height)
+        self.__set_context_color(self.__context, self.__colors["bg"])
+        self.__context.fill_preserve()
+        self.__context.stroke()
+
+        # stroke the inner rectangle
+        self.__context.rectangle(self.__inner.x, 
+                                 self.__inner.y,
+                                 self.__inner.width,
+                                 self.__inner.height)
+        self.__set_context_color(self.__context, self.__colors["bg"])
+        self.__context.fill_preserve()
+        self.__context.stroke()
+
+        # stroke the quad around
+        self.__context.move_to(self.__inner.x, self.__inner.y + self.__inner.height) 
+        self.__context.line_to(self.__inner.x, self.__inner.y)                     
+        self.__context.line_to(self.__inner.x + self.__inner.width - self.__mesh_x, self.__inner.y) 
+        self.__context.line_to(self.__inner.x + self.__inner.width - self.__mesh_x, self.__inner.y + self.__inner.height) 
+        self.__set_context_color(self.__context, (255, 255, 255))
+        self.__context.stroke()
+
+        # draw the actual bandwidth curves
+        self.__draw_bw(self.__in, self.__colors["fg_in"])
+        self.__draw_bw(self.__out, self.__colors["fg_out"])
+
+        # draw minimum, middle and max numbers
+        self.__draw_num(self.__inner.height + self.__inner.y, self.__str_min, (255, 255, 255))
+        self.__draw_num(self.__rect.height/2, self.__str_mid, (255, 255, 255))
+        self.__draw_num(self.__inner.y, self.__str_max, (255, 255, 255))
+
+    def __draw_num(self, ypos, num, color):
+        """ 
+        The leftmost column is used to draw info about maximum, minimum
+        and average bw
+        """
+        self.__context.move_to(5, ypos)
+        self.__context.show_text(num)
+        self.__set_context_color(self.__context, color)
+        self.__context.stroke()
+
+    def __draw_bw(self, bw_list, color):
+        """ Draws a curve from points stored in bw_list in color """
+        self.__context.move_to(self.__inner.x, self.__inner.y + self.__inner.height)
+        self.__set_context_color(self.__context, color)
+
+        x = self.__inner.x + self.__mesh_x
+        for i in bw_list[1:]:
+            self.__context.line_to(x, i)
+            x += self.__mesh_x
+        self.__context.stroke()
+
+    def __convert_one_hist(self, hist):
+        """
+        Maps values from one history object to real coordinates of the
+        drawing area
+        """
+        converted = list()
+
+        if self.__mesh_y == 0:
+            return [self.__inner.height + self.__inner.y] * len(hist)
+
+        for item in hist:
+            if item <= 100: item = 0     # treshold to get rid of really small peaks
+            converted.append((self.__inner.height - int(item / self.__mesh_y)) + self.__inner.y)
+        return converted
+
+    def __convert_points(self):
+        """
+        The bandwidth history object has the bandwidth stored as bytes. This method
+        converts the bytes into actual coordiantes of the rectangle displayed
+        """
+        # compute the aspect ratio
+        self.__mesh_x = float(self.__inner.width) / float(self.__size)
+        self.__mesh_y = float(self.maxval) / float(self.__inner.height)
+
+        self.__in  = self.__convert_one_hist(self.__hist["in"])
+        self.__out = self.__convert_one_hist(self.__hist["out"])
+
+    def __get_max(self):
+        """ Finds the maximum value in both incoming and outgoing queue  """
+        if self.__hist["in"]:
+            maxin = max(self.__hist["in"])
+        else:
+            maxin = 0
+        if self.__hist["out"]:
+            maxout = max(self.__hist["out"])
+        else:
+            maxout = 0
+        self.maxval = max(maxin, maxout)
+
+    def __text_size(self):
+        """ Computes the size of the text and thus the left border """
+        val = self.maxval
+        if val == 0 and self.maxval != 0:
+            val = self.maxval
+
+        self.__str_max = "%d %s" % (val, _("KB"))
+        self.__str_mid = "%d %s" % (val/2, _("KB"))
+        LoadGraph.padding["left"] = self.__context.text_extents(self.__str_max)[2] + 10
+
+    def __on_size(self, rect):
+        """ rect => a rectangle holding the size of the widget """
+        self.__rect  = rect
+
+        self.__inner.x = LoadGraph.padding["left"] 
+        self.__inner.y = LoadGraph.padding["top"] 
+        self.__inner.width = rect.width - LoadGraph.padding["right"] - self.__inner.x
+        self.__inner.height = rect.height - LoadGraph.padding["bottom"] - self.__inner.y
+
+        self.__convert_points()
+
+    def on_expose(self, widget, event):
+        """ A signal handler that is called every time we need to redraw
+        the widget """
+        self.__context = widget.window.cairo_create()
+
+        self.__get_max()
+        self.__text_size()
+        self.__on_size(widget.get_allocation())
+
+        self.__draw()
+
+        return False
+
+    def set_history(self, hist):
+        """ Called typically on change of interface displayed """
+        self.__hist = hist
+        self.__convert_points()
+
+    def update(self):
+        """ Redraws the area """
+        alloc = self.__widget.get_allocation()
+        self.__widget.queue_draw_area(0, 0, alloc.width, alloc.height)
+
+    def change_colors(self, col_in = None, col_out = None):
+        """ Sets the colors to draw the curves with """
+        if ( col_in )  : self.__colors["fg_in"] = col_in
+        if ( col_out ) : self.__colors["fg_out"] = col_out
+
+    def set_color(self, *args, **kwargs):
+        """ Sets the colors of the graph """
+        for key, value in kwargs.items():
+            self.__colors[key] = value
+
+class Monitor:
+    def __init__(self):
+        self.window = gtk.Window()
+        self.window.set_title(_("Network monitor"))
+        self.window.set_default_size(640, 440)
+        self.window.connect('delete-event', lambda *w: gtk.main_quit())
+
+        self.main_vbox = gtk.VBox()
+        self.window.add(self.main_vbox)
+
+        # notebook
+        self.notebook = gtk.Notebook()
+        self.main_vbox.pack_start(self.notebook)
+        #self.notebook.connect('switch-page', self.show_net_status)
+
+        self.ifaces = readnet()
+        self.enabled_ifaces = []
+
+        for iface in self.ifaces:
+            data_in, data_out = get_traffic(iface)
+            self.ifaces[iface] = {'data_in': 0,
+                              'data_out': 0,
+                              'total_in': 0,
+                              'total_out': 0,
+                              'widget_in': None,
+                              'widget_out': None,
+                              'widget_speed_in': None,
+                              'widget_speed_out': None,
+                              'graph': None,
+                              'histogram': [],
+                              }
+            iface_stat = self.build_iface_stat(iface)
+            self.notebook.append_page(iface_stat, gtk.Label(iface))
+            if self.check_network_accounting(iface):
+                self.enabled_ifaces.append(iface)
+
+        # configure timer
+        gobject.timeout_add(1000, self.update)
+
+        self.window.show_all()
+
+    def update(self, interval=1):
+        """Updates traffic counters (interval is in seconds)"""
+        for iface in self.ifaces:
+            old_data_in = self.ifaces[iface]['data_in']
+            old_data_out = self.ifaces[iface]['data_out']
+            total_in = self.ifaces[iface]['total_in']
+            total_out = self.ifaces[iface]['total_out']
+            data_in, data_out = get_traffic(iface)
+            # is it the first measure?
+            if old_data_in == 0 and old_data_out == 0:
+                old_data_in = data_in
+                old_data_out = data_out
+            # check total download
+            diff_in = data_in - old_data_in
+            diff_out = data_out - old_data_out
+            # checking for 32bits overflow
+            if diff_in < 0:
+                diff_in += 2**32
+            if diff_out < 0:
+                diff_out += 2**32
+            total_in += diff_in
+            total_out += diff_out
+            # speed
+            speed_in = diff_in / interval
+            speed_out = diff_out / interval
+            # update saved values
+            self.ifaces[iface]['data_in'] = data_in
+            self.ifaces[iface]['data_out'] = data_out
+            self.ifaces[iface]['total_in'] = total_in
+            self.ifaces[iface]['total_out'] = total_out
+            # update widgets
+            for widget, value in [('widget_in', total_in),
+                                  ('widget_out', total_out),
+                                  ('widget_speed_in', speed_in),
+                                  ('widget_speed_out', speed_out)]:
+                if widget in self.ifaces[iface]:
+                    self.ifaces[iface][widget].set_text(str(value))
+                else:
+                    print "%s not found in %s" % (widget, iface)
+            # updating graph
+            hist_in = self.ifaces[iface]['histogram']['in']
+            hist_in.append(speed_in)
+            if len(hist_in) > HISTOGRAM_SIZE:
+                del hist_in[0]
+            hist_out = self.ifaces[iface]['histogram']['out']
+            hist_out.append(speed_out)
+            if len(hist_out) > HISTOGRAM_SIZE:
+                del hist_out[0]
+            graph = self.ifaces[iface]['graph']
+            graph.update()
+        gobject.timeout_add(interval * 1000, self.update)
+
+    def check_network_accounting(self, iface):
+        """Checks if network accounting was enabled on interface"""
+        try:
+            os.stat("/var/lib/vnstat/%s" % iface)
+            return True
+        except:
+            return False
+
+    def build_iface_stat(self, iface):
+        """Builds graphical view for interface"""
+        iface_hbox = gtk.HBox()
+        # statistics vbox
+        stats_vbox = gtk.VBox()
+        iface_hbox.add(stats_vbox)
+        if self.check_network_accounting(iface):
+            # graph
+            graph_vnstat = gtk.Image()
+            pixbuf = self.load_graph_from_vnstat(iface, type="daily")
+            graph_vnstat.set_from_pixbuf(pixbuf)
+            stats_vbox.pack_start(graph_vnstat)
+            # buttons
+            frame = gtk.Frame(_("Show interface statistics"))
+            stats_vbox.add(frame)
+            vbox = gtk.VBox()
+            frame.add(vbox)
+            # summary
+            button = gtk.RadioButton(None, _("Summary"))
+            button.connect('toggled', self.update_stat_iface, (iface, graph_vnstat, "summary"))
+            vbox.pack_start(button, False, False)
+            # summary
+            button = gtk.RadioButton(button, _("Hourly traffic"))
+            button.connect('toggled', self.update_stat_iface, (iface, graph_vnstat, "hourly"))
+            vbox.pack_start(button, False, False)
+            # summary
+            button = gtk.RadioButton(button, _("Daily traffic"))
+            button.connect('toggled', self.update_stat_iface, (iface, graph_vnstat, "daily"))
+            vbox.pack_start(button, False, False)
+            # summary
+            button = gtk.RadioButton(button, _("Monthly traffic"))
+            button.connect('toggled', self.update_stat_iface, (iface, graph_vnstat, "monthly"))
+            vbox.pack_start(button, False, False)
+            # summary
+            button = gtk.RadioButton(button, _("Top 10 traffic days"))
+            button.connect('toggled', self.update_stat_iface, (iface, graph_vnstat, "top"))
+            vbox.pack_start(button, False, False)
+        else:
+            label = gtk.Label(_("Network accounting was not enabled on interface %s.\nPlease enable network accounting on the interface in order to view traffic statistics."))
+            stats_vbox.add(label)
+        # instant data vbox
+        traf_vbox = gtk.VBox()
+        iface_hbox.add(traf_vbox)
+        frame = gtk.Frame(_("Interface statistics"))
+        traf_vbox.pack_start(frame)
+        vbox = gtk.VBox()
+        frame.add(vbox)
+        # configuring callbacks
+        sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
+
+        # interface
+        iface_h, iface_p = self.build_value_pair(sizegroup, _("Network interface:"), iface)
+        vbox.pack_start(iface_h, False, False)
+        iface_s, iface_status = self.build_value_pair(sizegroup, _("Device status:"), _("Up"))
+        vbox.pack_start(iface_s, False, False)
+
+        # traffic
+        total_in_h, total_in = self.build_value_pair(sizegroup, _("Received data:"))
+        self.ifaces[iface]["widget_in"] = total_in
+        vbox.pack_start(total_in_h, False, False)
+        total_out_h, total_out = self.build_value_pair(sizegroup, _("Sent data:"))
+        self.ifaces[iface]["widget_out"] = total_out
+        vbox.pack_start(total_out_h, False, False)
+        speed_in_h, speed_in = self.build_value_pair(sizegroup, _("Download speed:"))
+        self.ifaces[iface]["widget_speed_in"] = speed_in
+        vbox.pack_start(speed_in_h, False, False)
+        speed_out_h, speed_out = self.build_value_pair(sizegroup, _("Upload speed:"))
+        self.ifaces[iface]["widget_speed_out"] = speed_out
+        vbox.pack_start(speed_out_h, False, False)
+
+        # graph
+        draw = gtk.DrawingArea()
+        vbox.pack_start(draw)
+        histogram = {"in": [], "out": []}
+        graph = LoadGraph(draw, histogram, HISTOGRAM_SIZE)
+        draw.connect('expose_event', graph.on_expose)
+        self.ifaces[iface]['graph'] = graph
+        self.ifaces[iface]['histogram'] = histogram
+
+        return iface_hbox
+
+    def build_value_pair(self, sizegroup, text, value_text=None):
+        """Builds a value pair"""
+        hbox = gtk.HBox()
+        name = gtk.Label(text)
+        hbox.pack_start(name)
+        value = gtk.Label(value_text)
+        hbox.pack_start(value)
+        sizegroup.add_widget(name)
+        return hbox, value
+
+    def update_stat_iface(self, widget, data):
+        """Updates graphic statistics"""
+        iface, graph, type = data
+        pixbuf = self.load_graph_from_vnstat(iface, type)
+        graph.set_from_pixbuf(pixbuf)
+
+    def load_graph_from_vnstat(self, iface, type="hourly"):
+        """Loads graph from vnstat. Right now uses vnstati to do all the dirty job"""
+        # load image from data
+        if type == "hourly":
+            param="-h"
+        elif type == "monthly":
+            param="-m"
+        elif type == "daily":
+            param="-d"
+        elif type == "top":
+            param="-t"
+        elif type == "summary":
+            param="-s"
+        else:
+            # show summary if parameter is unknown
+            print "Unknown parameter %s, showing summary.." % type
+            param="-s"
+        data = os.popen("vnstati %s -o - -i %s" % (param, iface)).read()
+        loader = gtk.gdk.PixbufLoader()
+        loader.write(data)
+        loader.close()
+        pixbuf = loader.get_pixbuf()
+        return pixbuf
+
+if __name__ == "__main__":
+    monitor = Monitor()
+    gtk.main()
-- 
cgit v1.2.1