To get these settings enabled by default, add the lines to your vimrc file, it is usually located at ~/.vimrc if not, just create it. Below is a part of the .vimrc file I like using.

"set tabwidth to 4 characters, automatic indentation and stuff
set tabstop=4 shiftwidth=4
set expandtab
set smarttab
set autoindent
set smartindent

"set searching case insensitive, but if you type uppercase, it will go case sensitive
set ignorecase
set smartcase

"2 lines above/below cursor when scrolling
set scrolloff=2

"show filename in title bar
set title

"show line numbers, and toggle it on/off with F2
set number
map <F2> :set invnumber<CR>

"toggle wrapping mode with Ctrl+w
map <C-w> :set invwrap<CR>

"Reload Current File, ask for confirmation if changed
map <F5> :confirm :edit<CR>

"automatically cd into the directory that the file is in, very useful when running commands within vi
autocmd BufEnter * execute "chdir ".escape(expand("%:p:h"), ' ')

"highlight the current line, when you split screen, it will only highlight the line that has focus on
hi CursorLine cterm=NONE ctermbg=blue ctermfg=NONE
autocmd WinEnter * setlocal cursorline
autocmd WinLeave * setlocal nocursorline
set cursorline

"set encoding to utf-8
set encoding=utf-8

"highlight search results
set hlsearch
"search while typing
set incsearch

The post Some Tips for VIM Users appeared first on VeriTeknik.

If you’re getting this error when starting phpMyAdmin, there are a few possibilities of what the problem may be.

For starters, be sure that it is a server side problem. If this only happens to one computer, just clear the browser cache and you’re good to go.

If that doesn’t solve the problem, it’s on the server.

PhpMyAdmin uses session intensely, check that the sessions folder of php is properly set.

Go to php.ini and look for the value session.save_path 

If there is a value for it, look for the path, it should be in mode 777 and owner root:user (change user with your own of course)

Sometimes this alone won’t solve the problem, check for you /tmp folder, if it is not 777, do it.

If this still does not solve the problem, clear the contents of the /tmp folder, some old session files stored in the /tmp folder do cause phpmyadmin to crash.

Since probably your /tmp folder is crowded, a simple rm -f /tmp/* might say “argument list too long”, in such case try this.

find /tmp -name '*' -print0 | xargs -0 -n 10 rm

The post PhpMyAdmin : Cannot start session without errors appeared first on VeriTeknik.

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.