A simple pythonic script to log internet bandwidth usage on Linux

We often want to log internet bandwidth on our laptops or PCs in order to track our usage over a period of time. This also comes handy to cross-check our usage with that of our ISP’s invoice. Now how to do it on linux? While the Windows folk have all kinds of utilities for this kind of thing, we lunix folk have to invent it ourselves.

Some time ago, I wrote this small python script that writes your bandwidth stats to a log file each time you disconnect your internet connection. This, I’ve tested on ubuntu 12.04 and debian wheezy:

Source file: Tata.py

#!/usr/bin/python
# author: Prahlad Yeri
import subprocess, os, datetime, sys
def execute(command):
    try:
        p=subprocess.Popen(command, shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
        p.wait()
        result=p.communicate()
        #print str(result)
        if len(result[0])>0:
            return result[0].strip()
        else:
            return result[1].strip()
    except Exception as e:
        print ‘error occured:’ + errorstring
        return errorstring
#main
mypath = ‘/etc/NetworkManager/dispatcher.d/’
iface = sys.argv[1].strip()
status = sys.argv[2].strip()
log=open(mypath + ‘tata.log’,’a’)
#log.write(iface + ‘:’ + status + ‘\n’)
#log.close()
for part in sys.argv:
        log.write(‘argv:’ + part + ‘\n’)
if (iface == ‘ppp0’ or iface == ‘ttyUSB0’) and status == ‘down’:
        s = execute(‘iptables -L -v’)
        rules = s.splitlines()
        rx,tx = 0,0
        rxdrop, txdrop = 0,0
        inrule = False
        outrule = False
        for rule in rules:
                log.write(‘rule:’ + rule.strip() + ‘\n’)
                words = rule.strip().split()
                if rule.strip().startswith(“Chain OUTPUT”):
                        log.write(‘switch to outrule’)
                        outrule = True
                        inrule = False
                elif rule.strip().startswith(“Chain INPUT”):
                        log.write(‘switch to inrule’)
                        inrule = True
                        outrule = False
                elif rule.strip().startswith(“Chain FORWARD”):
                        log.write(‘switch to no rule’)
                        inrule=False
                        outrule=False
                elif len(words) >=3:
                        if words[6].strip() == “ppp0”:
                                #log.write(‘bytes=’ + words[1]
                                if inrule:
                                        if words[2].strip() == ‘DROP’:
                                                rxdrop += int(words[1].replace(‘K’,’000′).replace(‘M’,’000000′))
                                        else:
                                                rx += int(words[1].replace(‘K’,’000′).replace(‘M’,’000000′))
                                elif outrule:
                                        if words[2].strip() == ‘DROP’:
                                                txdrop += int(words[1].replace(‘K’,’000′).replace(‘M’,’000000′))
                                        else:
                                                tx += int(words[1].replace(‘K’,’000′).replace(‘M’,’000000′))
        #print ‘rx=’ + str(rx) + ‘ tx=’ + str(tx)
        #print ‘rxdrop=’ + str(rxdrop) + ‘ txdrop=’ + str(txdrop)
        execute(“iptables –zero”)
        header=”
        lines=[]
        if not os.path.exists(mypath + ‘usage.csv’):
                #create header
                header = ‘date,rx,tx,rx-dropped,tx-dropped,rx-tot,tx-tot\n’
        f = open(mypath + ‘usage.csv’,’a’)
        if len(header) > 0:
                lines.append(header)
        lines.append(str(datetime.datetime.now()).split(‘.’)[0] + ‘,’ + str(rx) + ‘,’ + str(tx) + ‘,’ + str(rxdrop) + ‘,’ + str(txdrop) + ‘,’ + str(rx+rxdrop) + ‘,’ + str(tx+txdrop) + ‘\n’)
        #rx = execute(‘cat /sys/class/net/ppp0/statistics/rx_bytes’)
        #tx = execute(‘cat /sys/class/net/ppp0/statistics/tx_bytes’)
        #strdate=str(datetime.datetime.now())
        #line = strdate + ‘,’ + rx + ‘,’ + tx + ‘\n’
        f.writelines(lines)
        f.close()
        log.close()
        sys.exit(0)

In the above script, replace ppp0 with the interface-name for the name of interface through which you access internet. For mobile broadbands it is typically ppp0, but you can issue the “ifconfig” command to list them all and make sure.

You have to place this script at /etc/NetworkManager/dispatcher.d on debian/ubuntu systems so that it runs each time you stop using the modem. In case of other systems, or in case you don’t use NetworkManager, refer to your distro documentation to check the folder/script which is executed when an interface is down.

Android app can now save people’s lives!

PressureNET
PressureNET

Don’t believe it? I too didn’t until I read about this PressureNET open-source android app recently. This is a crowd-sourced app and its working is simple: Just gauge these two parameters:

1) Atmospheric pressure using the pressure sensors (available in latest android phones like Galaxy S4/Nexus), and

2) GPS coordinates using the GPS sensor.

and send the data to the PressureNET web-server through Internet. Now, with enough number of people running this app on their devices, weather scientists across the nation have access to substantial data regarding pressure-belts forming in various parts of the country. They can then input this data to their weather modeling systems and come-up with solid predictions! (not just vague guesses like now) regarding for example, when and exactly where the next hurricane is going to hit. According to Cliff Mass, an atmospheric Scientist at the University of Washington, this data can help predict an occurrence of a hurricane up to six hours earlier. There is currently, no technique to do it now.

Whilst the pressure-sensor is being used for this purpose, the intentions of Google was something totally different when putting this feature into the android OS. It was to fetch the altitude information. You see, the GPS tells you only the Geo-coordinates (Lat/Lon) on a plane surface. But the atmospheric-pressure changes as a person travels uphill or downwards, and thus it can let us know exactly what altitude a person is on!

 

 

 

References:

http://en.wikipedia.org/wiki/PressureNET

http://www.wired.co.uk/news/archive/2013-01/08/android-weather-app

A Python finds out which is the best performing Linux distro!

python

With more and more linux distributions competing among themselves for the userspace, we are currently living in the best of times as far as choice in open-source software is concerned. However, more the number of choices, more is the head-scratching to decide what to choose amongst them. Like many, I am also one of the victims of “distro-hopping”. No sooner a major distribution declares a new version, I’m itching to try one out in my virtual box or as a LiveCD version. Few days ago, this benchmarking idea occurred to me.

I’m a software developer and my requirements were clear. I wanted a distro that is good at performance. Since my desktop is cluttered with “heavy-duty” programs like Eclipse-ADT, Java, IDLE, etc., performance was my primary concern. I mostly write application software and android apps, so things like disk I/O, memory and CPU utilization matter.

With these things in my mind, I was seeking a simple way to do a quick benchmark of various distros to find out what suits my needs. Thats when this idea came to me – Almost all distros come preloaded with a general-purpose scripting language called python which could be summoned for the job. I took “time taken in milliseconds” to do 5 basic tasks to decide on the performance. These tasks were:

  1. Zip-test: A test to compress a large file to a zip file, and extract in back in python code.
  2. Random-test: Generate 5 million random numbers and round them to zero decimals.
  3. I/O test: Write a unicode string ‘spam and eggs’ 5 million times to a text file, and read them back.
  4. CSV test: Generate a CSV spreadsheet with 5 million rows in it, and read them back.
  5. Bandwidth test: Download the 800K akonadi RPM file from IIT Kanpur’s website.

(The last one was just for the sake of completeness. Internet bandwidth depends more on other parameters such as your ISP limits, time of the day, latency, etc. rather than the disto you are using).

The contestants in the arena were:

  1. openSUSE 12.2
  2. Debian 7 (GNOME version)
  3. Fedora 18
  4. Ubuntu 12.04 LTS
  5. Xubuntu 12.04

My previous experience with Ubuntu made be biased towards it, but the tests showed me how wrong I was. Also, from what I’d read in most blogs on the Internet, KDE was one of the most bloated distros ever. However, in my tests KDE on openSUSE topped the race in most parameters, though the credit should go to openSUSE for optimizing the KDE. The second spot saw Fedora and Debian fighting amongst them, while Ubuntu (that I was presently using) fared the worst! Here are the detailed results:

Test zt1

(compress)

zt2

(archive)

random io csv bandwidth
debian1 7622 2753 9142 5732 12784 118978
debian2 7724 2752 9161 5287 12112 92386
fedora18_1 8605 4168 6287 5972 12750 0
fedora18_2 7762 4164 6419 6160 12818 0
openSUSE1 9001 2313 5915 5904 12715 115999
openSUSE2 7253 2245 6035 5935 11492 71257
precise1 9649 5012 8807 6846 13552 78560
precise2 10555 4434 8890 7229 13455 48286
xubuntu1 13305 4827 8954 5839 14676 58538
xubuntu2 10826 4760 8934 7908 12802 52768

*Above figures represent time-taken in milliseconds

The bandwidth test could not be performed on fedora as the Live CD did not have the wget package installed, but I did not need that to get a general idea of things.

My Conclusion: openSUSE wins the race, though Debian-7 and Fedora-18 are also fine distros for performance.

Here is the entire python benchmarking script that you may customize as per your requirement (change initializing variables in the script and run by issuing “python benchmark.py” from the shell):

 

import sys,time,os
import zipfile,random,csv
import subprocess
from zipfile import ZipFile,ZIP_DEFLATED
from random import random

##Variables
#This should be initially present before running the program:
test_name=’debian1′
file_to_extract = “VirtualBox.exe” #”dotnetfx35.exe”
##

def timer(test):
t1=time.time()#.clock()
elapsed=0
#
if test == “ziptest1”:
ziptest1()
elif test == “ziptest2”:
ziptest2()
elif test == “randomtest”:
randomtest()
elif test==”iotest”:
iotest()
elif test==”csvtest”:
csvtest()
elif test==”bwtest”:
bwtest()

elapsed=time.time()-t1
timetaken=round(elapsed*1000,0)
print test,timetaken,”msecs.”
return timetaken

def ziptest1():
myzip=zipfile.ZipFile(‘t.zip’,’w’,ZIP_DEFLATED) #ZIP_STORED
myzip.write(file_to_extract)
myzip.close()
return

def ziptest2():
os.remove(file_to_extract)
myzip=zipfile.ZipFile(‘t.zip’,’r’)
myzip.extractall()
myzip.close()
return

def randomtest():
for i in range(1,5000000):
r = round(random()*100,0);
#print r
return

def iotest():
file=open(‘myfile1k.txt’,’w’)
for i in range(1,5000000):
file.write(u’spam and eggs’)
file.close()
#
file=open(‘myfile1k.txt’,’r’)
s=file.readline()
while (s!=”):
#print s
s=file.readline()
file.close()
return

def csvtest():
file=open(‘myfile.csv’,’w+b’)
#
writer= csv.writer(file,delimiter=’,’,quotechar=’|’)#,quoting=csv.QUOTE_MINIMAL)
for i in range(1,5000000):
writer.writerow([‘spam’,’eggs’,’spam1′])
#writer.close()
file=open(‘myfile.csv’,’r+b’)
reader=csv.reader(file,delimiter=’,’,quotechar=’|’)
for row in reader:
s= ‘,’.join(row)
#reader.close()
#
file.close()
return

def bwtest():
subprocess.call([“wget”,”http://mirror.cse.iitk.ac.in/fedora/releases/18/Fedora/i386/os/Packages/a/akonadi-1.8.1-1.fc18.i686.rpm”,”-O akonadi.rpm”])
#subprocess.call([“wget”,”http://www.google.com”,”-O”,”akonadi.rpm”])
return

if __name__ == “__main__”:
#print time.strftime(“%d-%m-%y %H:%M”, time.gmtime())
#print time.strftime(“%d-%m-%y %H:%M”, time.localtime())
zt1=timer(“ziptest1”)
zt2=timer(“ziptest2”)
random=timer(“randomtest”)
io=timer(“iotest”)
cst=timer(“csvtest”)
bw=timer(“bwtest”)

#Store results to csv file.
file=open(‘results.csv’,’ab’)
writer= csv.writer(file,delimiter=’,’,quotechar=’|’)
#writer.writerow([‘test’,’zt1′,’zt2′,’random’,’io’,’cst’,’bw’])
writer.writerow([test_name,zt1,zt2,random,io,cst,bw])
file.close()
print ‘\n\nWritten results.csv’
#
exit(0)

How to create a screencast on your linux desktop

Screen casting is the act of recording your desktop while you do something, for example, running an application, replicating a test-case scenario or creating a training video, etc. Optionally you may or may not want your voice being recorded along with the video. Whilst there are many free and popular tools available for Windows to do such a task, in the Linux world the de-facto standard is a nifty little program called recordMyDesktop. Apart from a command line interface, it also has a very simple but elegant GUI that lets you easily create a screencast with audio recording enabled, while also providing you the option to specify some advanced settings such as screen co-ordinates (the area on your desktop you want recorded), audio/video input devices and the number of channels:

recordMyDesktop

The above image shows recordMyDesktop program running on my Ubuntu 12.04 Linux distro. All you have to do is set the video quality and optionally set the sound quality if you also need voice recording. Most of the time, there is no need to open Advanced Settings. A few scenarios I can think of is where you want to specify an explicit FPS (Frames per second) value, apart from the default which is 15. Or else, you want to specify an explicit screen resolution.

There is also a feature that enables you to record a single window instead of the entire desktop. Just use the select “window button” on bottom left corner to do so.

Once the recording is done, the program encodes the video in .ogv (Ogg Vorbis) format as saves in your home folder with the filename, “out-n.ogv”. Ogg Vorbis is a pretty standard video format most modern programs are able to play.

Installing this program on your linux desktop is pretty easy. Depending on your package management system, this is usually done by issuing a single command in your terminal:

sudo apt-get install recordMyDesktop

This is for apt-based distros such as Debian and Ubuntu. On Fedora you may use yum, or zypper on openSUSE.

Fedora vs Ubuntu vs Linux Mint for Performance

Fedora vs Ubuntu vs Linux Mint

The never ending search for that “holy grail” distribution keeps most people downloading and hopping from one distro to another without ever bothering to ask themselves why they want to use an operating system in the first place. I don’t blame them, as nowadays, the ever active “assembly-lines” of various distro factories like ubuntu, fedora and linux-mint are enough to boggle the minds of most newbies by throwing an enormous number of configuration options.

Until some time ago, I myself was one of those “holy grail” seekers endlessly installing one distro after another in the second partition of my hard drive which is always reserved for Linux. Since my full time job involves .NET programming for my organization, I have to keep the first one reserved for Win7 of course.

Anyways, coming back to my Linux endeavors, I decided to pause and look inwards. I asked myself why do I want to use Linux? Thats because I want to: 1) Learn and understand the Linux operating system and programs using a top-down approach, and 2) Learn programming on Linux – this involves a lot of things including C++, GTK+, Qt, Android and the suchlike, and 3) Doing miscellaneous things such as listening to music, some light gaming, etc.

The most obvious thing that occurred to me was one word – performance. I don’t need high-end graphics. I’m never getting into serious gaming stuff such as OpenGL. All I need is a distro that can handle as many applications and programs as I can throw at it. Since I don’t have time for doing things from scratch like LFS or ArchLinux, I shortlisted the below three candidates:

1. Ubuntu 12.04 LTS – Precise Pangolin

2. Linux Mint 14.1 – Nadia

3. Fedora 18 – Spherical Cow

Rather than search for existing benchmarks, I decided to put these gladiators in my own arena. I prepared my 16GB pendrive for a multi-boot with the above three Live versions and started testing them one by one. The stuff I threw at them was things I would normally do, such as extracting a huge (4GB) archive, format a USB pendrive, surf the net, etc. Here is how each one of them fared in the fight:

Distro Benchmarking

The verdict: Unlike the gladiators of Rome where one used to absolutely dominate over the other, the case of these linux distros is entirely different. One distro fared well in one area, while the other fared in another. For instance, Fedora was good at CPU usage, while Linux-mint did well in the RAM area. However, for my purposes, I regard Linux-mint as an ideal choice overall.

How to add or remove launchers from your gnome classic/fallback desktop panel

This is a nice little hack that comes handy when you want to add or remove launchers (shortcuts to your favorite programs such as firefox or gedit) to an existing panel, or add an entirely new panel to your gnome-classic or fallback desktop. On my Linux Mint workstation, I prefer the gnome-classic version instead of the default cinnammon desktop for reasons of speed and simplicity. I soon found out, however, that process of adding/removing launchers or adding a new panel requires a special key combination that is not easily found without going through some extensive documentation!! Here is how you do it:

To add a new launcher:

1. Press the WIN (Super) and ALT keys together.
2. While keeping them pressed, right-click the panel.
3. You will then get a popup menu saying “New Panel”, or “Add to Panel”.
4. Click on the second option and select your program.

To edit/remove an existing launcher:

1. Follow steps 1 & 2 from above.
2. You will get a popup menu saying “Move” and “Remove from Panel”.
3. Click on your choice.

How to make brightness changes permanent in your Linux Desktop?

Quite recently, I’ve faced this nagging little issue on all the distros I tried. These included Ubuntu 12.04 LTS, Linux Mint 11.1 and Fedora 18. Whenever I changed my computer’s brightness setting either through the gnome-settings applet or by using hotkeys, the changes were only temporary. On next reboot, they would vanish!! Now what is the easiest way to make your chosen setting permanent? After much googling and head-scratching, I finally arrived at the answer.

First of all, NEVER place anything like this in a startup script:

echo 4 > /sys/class/backlight/acpi_video0/brightness

(See this update if you found this folder empty or missing)

Although this command might change your brightness, again the effects are only temporary and will be lost on your next reboot. If you attempt to place this in /etc/rc.local, it may not always work due to permission issues. Instead of ending up chmod-ing the permissions to the brightness file and cause any other issues in turn, the recommended approach is to use xbacklight, the tool fit for this purpose.

Here is the easy way:

1. Install xbacklight from your package repository. On Linux Mint, I did this:

sudo apt-get install xbacklight

2. Place xbacklight command with your chosen settings in your “startup-applications” applet. In my case I had the command: xbacklight -set 50

On Mint Linux, it looked something like this:

Image for xbacklight-startup
Configure xbacklight in startup-applications applet

Thats all. This effectively sets brightness to 50% by default upon your each login. Enjoy!!

UPDATE on 04-mar-2013: I came to know today that the 3.4 kernel has broken some things related to acpi-support for setting brightness. As a result of that the /sys/class/backlight folder is empty and the xbacklight program also won't work!! Solution? Either upgrade/downgrade your kernel or add "acpi_backlight=vendor" to your menu.lst. See this link for more information:

http://superuser.com/questions/548459/how-to-change-screen-brightness-on-toshiba-satellite-l850-djs-in-linux/556745#comment683067_556745