While using Python as a system scripting tool, it’s essential to keep using the standard gnu tools if possible, since these tools are reliable, fast and have been tested for years by thousands of other system administrators as well.

The best way to keep using your good old fashioned gnu tools via Python is opening pipes to such tools. Even though it is possible to use the os module to do such tasks, the subprocess module is more reliable and you have more control over the tasks.

Below you’ll see two different methods to approach the “echo” tool via Python.

>>> import os, subprocess
>>> os.system("echo bla")
bla
0
>>> subprocess.Popen(["echo","bla"],stdout=subprocess.PIPE).communicate()[0]
'bla\n'

As you can see, both give us more or less the same output, but the subprocess module gives us a lot more control. First of all it has pipe support, universal newline support, better handling of exceptions etc.

Below is a method I use to determine the number of processor on the system. Using this, you can find out if you have multiple cores on the system.

cpu_num=subprocess.Popen(["grep","-c","processor","/proc/cpuinfo"],stdout=subprocess.PIPE).communicate()[0]

As you can see, what is does is very very simple, it just counts the number of word “processor” in the /proc/cpuinfo file using grep.

Don’t forget that it is very easy to pipe commands through each other with popen, here’s an example.

>>> import subprocess
>>> p1=subprocess.Popen(["cat","/proc/cpuinfo"],stdout=subprocess.PIPE)
>>> p2=subprocess.Popen(["grep","-B","2","-A","2","processor"],stdin=p1.stdout,stdout=subprocess.PIPE)
>>> output = p2.communicate()[0]
>>> print output
processor : 0
vendor_id : GenuineIntel
cpu family : 15

Using the popen, it is very easy to get information on processes via the pgrep and ps tools. Below is a script when run with the valid parameters, checks if any of it’s processes uses more (or equal) to the percentage of the CPU specified, if true, kills the process and tries to send a message to the affiliated terminal window.

To accomplish this, we get the pid’s of the processes via pgrep, send it to ps so to check the cpu percentage and which tty (or pts) it’s running on. After the check, if necessary, the PID is killed and a message is sent to the terminal it was running on.

#!/usr/bin/python
import subprocess, sys, string

if len(sys.argv) != 3 :
    print "Usage : cpukiller.py <process-to-kill> <max-cpu-percentage>"
    raise SystemExit

proc_to_kill = sys.argv[1]
cpu_to_kill = sys.argv[2]

for i in cpu_to_kill :
    if i not in string.digits :
        print "max-cpu-percentage must consist of only digits."
        raise SystemExit

cpu_to_kill = int(cpu_to_kill)

try :
	a=subprocess.Popen(["pgrep",proc_to_kill],stdout=subprocess.PIPE).communicate()[0]
	if a == '' :
		raise SystemExit
	else :
		procc = subprocess.Popen(["ps --no-headers -o pid,pcpu,tname -p $(pgrep %s)"%proc_to_kill],shell=True,stdout=subprocess.PIPE).communicate()[0]
		procc=procc.strip()
except : raise SystemExit 
for lines in procc.split('\n') :
    if lines != '' :
        l=lines.split()
        if int(l[1].split('.')[0]) >= cpu_to_kill :
            if l[2] != '?' :
                try :
                    terminal = open('/dev/'+l[2],'a')
                    subprocess.Popen(["echo","You have exceeded your CPU limit, process with PID %s will be terminated"%l[0]],stdout=terminal).communicate()[0]
                except :
                    print "Couldn't tell the user."
                    pass
            try :
                killer = subprocess.Popen(["kill","-9",l[0]],stdout=subprocess.PIPE).communicate()[0]
            except :
                print "Couldn't kill the process."
                pass
        else : pass

Try to use it, understand it, and expand it!

The post System Control Over Python With Pipes appeared first on VeriTeknik.

The main goal is to check whether we get any response from the FTP server while we try to connect anonymously. Don’t forget that this script probably won’t work if the FTP server allows anonymous connections.

We simply use the ftplib module to establish the FTP connection. After the successful (or failed) connection, we can report the status of the server via email, to achieve this we use the smtplib module.

The first lines seem simple,

#!/usr/bin/python
import ftplib, smtplib
server_ip='10.20.30.40'
sender='sender@email.com'
receivers=['john@email.com','doe@email.com']

Above, after importing our modules, we’ve defined the ip address of our FTP server. After that, the sender email address is defined, and then a list containing the receivers.
Now we can define our messages. We’ll have two messages, one for the UP status, and one for the DOWN.

message_up="""
 From: FTP Status DAEMON 
 To: John , Doe 
 Subject: FTP Service Running
The FTP Service on %s is running.
 """ % server_ip
message_down="""
 From: FTP Status DAEMON 
 To: John , Doe 
 Subject: FTP Service DOWN!
The FTP Service on %s is DOWN!!!
 """ % server_ip

Now we can actually start the checking. The first try clause is checking if we can establish any kind of connection with the server. If the server is somehow down, or if only the FTP service is shut down, this will return some sort of error, which we will catch with the except clause, handle it with our smtp commands, then raise a system exit.

try : ftp=ftplib.FTP(server_ip)
except :
 print "FTP DOWN !!!"
 smtpObj = smtplib.SMTP('localhost')
 smtpObj.sendmail(sender,receivers,message_down)
 raise SystemExit

And here’s the second check, if we somehow get to this line, it means that we’ve passed the system exit above, so our connection attempt with the server worked, but we’re not sure if the FTP service is actually running without a login attempt. When we try to login, and if anonymous connection isn’t allowed, we’ll get a permission error, handling it with an exception we can email the recievers that the server is running.

try : ftp.login()
except ftplib.error_perm :
 print "FTP Up, Permission Denied."
 smtpObj = smtplib.SMTP('localhost')
 smtpObj.sendmail(sender,receivers,message_up)

Now simply connect the dots and add the whole script to your crontab, then you’re good to go!

The post A Simple FTP Status Daemon appeared first on VeriTeknik.

First of all don’t forget that this module is only available if you’re using a Red Hat branch of distribution (fedora, centos etc.) For other distributions, such as Debian, there are other api’s, such as apt itself.

Below you’ll find some basic ways of getting configuration settings of the current yum.

import yum
yb = yum.YumBase()
print yb.conf.logfile # this will obviously printout the logfile's path
for i in yb.conf.reposdir : print i # and this will printout the directories and files for the repositories
print yb.conf.skip_broken # usually false. when set to true, your yum commands will take action of is the --skip-broken parameters was given to the yum itself.
print yb.conf.errorlevel # this is the level of errors you'd like to get as an output. it's between 0-10 and 0 is only critical ones, while 10 is more like a debug feature. Usually it is set to default 2, but since you'll be running in a script, after your script gets stable, its a good idea to set this to 0 and then distribute it.
print yb.conf.config_file_path # obvious again, the file path for your yum's config file.

for more configuration options, you can always see like this;

dir(yb.conf)

and don’t forget this perfect module, to reverse engineer some function if you don’t know what arguments it gets and if it’s poorly documented (ex: it doesn’t have a valid __doc__ attribute) :

import inspect
inspect.getargspec(somefunction)

And about the arch method. What yum knows about our architecture.

import yum
yb = yum.YumBase()
print yb.arch.compatarches # these are the compatible architectures with our system.
# below are the arch types that yum thinks we are usig (hopefully true!)
print yb.arch.canonarch
print yb.arch.basearch
# With the function below, you can get a list of architectures which are compatible with each other.
# Let's say you're using an x86_64 arch, then u can use packages from these ones,
yb.arch.get_arch_list('x86_64')
['x86_64', 'athlon', 'i686', 'i586', 'i486', 'i386', 'noarch']

If you’d like to get the currently installed packages on your system, rpm is the module you’d like to load.

import rpm
bold = "\033[1m"
reset = "\033[0;0m"
trans = rpm.TransactionSet()
for header in trans.dbMatch() : print "%s%s%s-%s:%s-%s.%s%s%s" % (bold,header['name'],reset,header['epochnum'],header['version'],header['release'],bold,header['arch'],reset)

Note that this script outputs various parts in bold. You can use this in any script you’d like.

Yet here’s a nice method to install new packages.

import yum
yb=yum.YumBase()
searchlist=['name']
arg=['gedit']
matches = yb.searchGenerator(searchlist,arg)
for (package, matched_value) in matches :
    if package.name == 'gedit' : yb.install(package)
    yb.buildTransaction()
    yb.processTransaction()

Experiment, enjoy!

The post Using the Python API for Yum appeared first on VeriTeknik.