I’m not gonna describe how to make HTML form and how to parse input data from html. I leave these as you your homework ;). As storage for HTTP sessions I chose database(specifically MYSQL).

Here is my table with sessions :

desc mc_sessions;
+-----------------+--------------+------+-----+---------+-------+
| Field           | Type         | Null | Key | Default | Extra |
+-----------------+--------------+------+-----+---------+-------+
| user_name       | varchar(50)  | YES  |     | NULL    |       |
| session_id      | varchar(255) | NO   | PRI | NULL    |       |
| expiration_time | int(11)      | YES  |     | NULL    |       |
+-----------------+--------------+------+-----+---------+-------+

use CGI qw/:standard/;
use CGI::Cookie;

sub set_cookies {.
    my ($db,$user_name,$user_passwd) = @_;

    my $exp_time = time() + 259200; #(3 days)
    my $session_id = md5_hex($user_id.''.$user_name.''.$user_passwd.''.$exp_time);

    my $sth = $dbh->prepare("INSERT INTO $table (user_name,session_id,expiration_time) VALUES (?,?,?)");
    $sth->execute($user_name,$session_id,$exp_time);

    my $cookie1 = new CGI::Cookie(-name=>'SessionID',-value=>"$session_id");
    my $cookie2 = new CGI::Cookie(-name=>'ExpirationTime',-value=>"$exp_time");

    print header(-cookie=>[$cookie1,$cookie2]);

    return 1;
}

sub check_auth {
    my ($dbh) = @_;

    my %cookies = fetch CGI::Cookie;
    my %cook_hash;

    foreach my $key (sort keys %cookies) {
        $cookies{$key} =~ /=(.*);/;
        $cook_hash{$key} = $1;
    }

    return -1 if (!defined($cook_hash{SessionID}));

    my $user_name = is_session_valid($dbh,$cook_hash{SessionID});

    return -1 if ($user_name == -1);

    return $user_name;
}

sub is_session_valid {
    my ($dbh,$session_id) = @_;

    my ($exp_time);

    my $sth = $dbh->prepare("SELECT * FROM sessions WHERE session_id=? and expiration_time > ?");
    $sth->execute($session_id,time());

    while ( my @array = $sth->fetchrow_array ) {
            ($user_name,$session_id,$exp_time) = @array;
    }

    return $user_name if (defined($user_name) and $exp_time > time());

    return -1;
}

As result we have 3 functions.

1. set_cookies – this function generate, put in database and send cookies to user’s browser.
2. check_auth – check if user has already have some cookies from server if yes call is_session_valid for future checking.
3. is_session_valid – look about user’s  session id  and check whether this session was expired or not.

Pay attention:

Each function receives variable $dbh it’s database connection identificator and should be created before function run.

How does it use?

Edit you CGI code. And take care that all pages checks sessions id.
Put this function call after authorization by password to send cookies to user:

set_cookies($dbh,$username,$password);

And these in all remains site’s pages to prevent site from unauthorized actions:

my $user_name = check_auth($dbh);

if ( $user_id == -1 ) {
        some action[s]
}

There is some listing of my script I hope this example help you to understand some fundamental points in IP math.

#!/usr/local/bin/perl
# Written by Andrii Grytsenko 2010
# PP: http://andriigrytsenko.net    

use POSIX;

sub hex2bin {
   my $hex = shift;
   my $pack = unpack("B32",pack("N",$hex));
   my $pack = substr($pack,-8);
   return $pack;
}                                          

sub bin2hex {
   my $bin = shift;
   return unpack("N", pack("B32", substr("0" x 32 . $bin, -32)))
}                                                               

sub bin2ip {
    my $bin = shift;
    my $type = shift;
    my $ip;
    $ip .= bin2hex(substr($bin,0,8)) ."\.";
    $ip .= bin2hex(substr($bin,8,8)) ."\.";
    $ip .= bin2hex(substr($bin,16,8)) ."\.";
    if ( $type eq 'first') {
        $ip .= bin2hex(substr($bin,24,8)) + 1 ;
    } elsif ($type eq 'broad') {
        $ip .= bin2hex(substr($bin,24,8)) - 1 ;
    } else {
        $ip .= bin2hex(substr($bin,24,8));
    }
    return $ip;
}

sub normalization {
    my $line = shift;
    my ($ip,$mask) = split(/\//,$line);
    return($ip,$mask);
}

my ($ip,$net_mask) = normalization(@ARGV[0]);

my $host_mask = 32-$net_mask;
my $max_host = POSIX::pow(2,$host_mask)-2;
my $bin_mask = "1" x $net_mask . "0" x $host_mask;

my $bin_ip ;
$bin_ip .= hex2bin($_) foreach (split(/\./,$ip));

my $min = $bin_ip & $bin_mask;
my $max_mask = "0" x $net_mask . "1" x $host_mask;
my $max = $bin_ip  | $max_mask;

my $min_ip = bin2ip($min);
my $min_host_ip = bin2ip($min,'first');
my $max_ip = bin2ip($max);
my $max_host_ip = bin2ip($max,'broad');

print \<\< EOF
IP ADDRESS:\t $ip\t $bin_ip
NETWORK MASK:\t \/$net_mask\t\t $bin_mask
WILDCARD:\t \/$host_mask\t\t $max_mask
NETWORK IP:\t $min_ip\/$net_mask\t $min
BROADCAST ADDR:\t $max_ip\t $max
FIRST ADDR:\t $min_host_ip
LAST ADDR:\t $max_host_ip
MAX HOSTS\t $max_host
EOF

Run scripts with one argument ip/netmask... Unfortunately, you can use only short network mask type :

./ipcalc 192.157.9.3/21

the output looks like this:

IP ADDRESS:      192.157.9.3     11000000100111010000100100000011
NETWORK MASK:    /21             11111111111111111111100000000000
WILDCARD:        /11             00000000000000000000011111111111
NETWORK IP:      192.157.8.0/21  11000000100111010000100000000000
BROADCAST ADDR:  192.157.15.255  11000000100111010000111111111111
FIRST ADDR:      192.157.8.1
LAST ADDR:       192.157.15.254
MAX HOSTS        2046

I used perl module Benchmark to make measurements. Rules:

1. If you can use single quotes instead of double quote, do it. In most cases it will be executed more faster because of string in single quotes is not going to concatenate.

2. Use compiled regexps in case you have loops. It can brings huge performance:

use Benchmark;

sub qwe {
    my $re = shift;
    my $line = "wer";
    foreach my $reg (@$re){
        if ( $line =~ /$reg/) {
            my $l=0;
        }
    }
}

my $line = "sdfsdfsdfsdf";
my $ref = ".*";
my @arr = qw(qwe sdf wer); #plaine regexps
my @c_re;
foreach my $p_re (@arr) { # compile it and put in to the @c_re
    my $re = qr/\b$p_re\b/i ;
    push(@c_re,$re);
}

Benchmark::cmpthese(100000, {
    'Compiled' => sub { qwe(\@c_re) },
    'Not_compiled' => sub { qwe(\@arr) },
});

As result:

                 Rate Not_compiled     Compiled
Not_compiled  36232/s           --         -79%
Compiled     169492/s         368%           --

3. Extract values from string with substr if you can. There are three well knows ways to do such kind of operation: regular expressions, split and substr. Let’s compare it:

sub mksplit {
    my ($line) = @_;
    my ($fst,$snd) = split(/-/,$line);
    return($fst,$snd);
}

sub mkregexp {
    my ($line,$re) = @_;
    $line =~ m/$re/;
    return($1,$2);
}

sub mkstr {
    my ($line) = @_;
    my $pos = index($line,'-');
    my $fst = substr($line,0,$pos);
    my $snd = substr($line,$pos+1);
    return($fst,$snd);
}

my $line = "12-34";
my $n_comp_re = '(\d+)-(\d+)';
my $comp_re = qr/\b$n_comp_re\b/i ;

Benchmark::cmpthese(1000000, {
    'Compiled' => sub { mkregexp($line,$comp_re) },
    'Not_compiled' => sub { mkregexp($line,$n_comp_re) },
    'STR' => sub { mkstr($line) },
    'Split' => sub { mksplit($line) },
});

Benchmark::timethese(1000000, {
    'Compiled' => sub { mkregexp($line,$comp_re) },
    'Not_compiled' => sub { mkregexp($line,$n_comp_re) },
    'STR' => sub { mkstr($line) },
    'Split' => sub { mksplit($line) },
});

Where compiled and not_compiles we use when talk about regular expression.

                 Rate        Split     Compiled Not_compiled          STR
Split        297619/s           --          -9%         -12%         -25%
Compiled     327869/s          10%           --          -4%         -17%
Not_compiled 340136/s          14%           4%           --         -14%
STR          396825/s          33%          21%          17%           --
Benchmark: timing 1000000 iterations of Compiled, Not_compiled, STR, Split...
  Compiled:  4 wallclock secs ( 3.14 usr +  0.00 sys =  3.14 CPU) @ 318471.34/s (n=1000000)
Not_compiled:  3 wallclock secs ( 2.91 usr +  0.00 sys =  2.91 CPU) @ 343642.61/s (n=1000000)
       STR:  2 wallclock secs ( 2.53 usr +  0.00 sys =  2.53 CPU) @ 395256.92/s (n=1000000)
     Split:  3 wallclock secs ( 3.19 usr +  0.00 sys =  3.19 CPU) @ 313479.62/s (n=1000000)

As you can see from output the more faster way to exract values from string is substr, next is split and regular expressions is the most slower. I don’t know why compiled regexps is more slow than regular one in this case. I guess its because of 1 iteration.

4. Don’t use sort in hash loops if there is no necessity. The most faster way to through over the hash is keys statement:

sub mkeach {
    my $hash = shift;
    my %hash2;
    while ( my($key,$value) = each(%$hash)){
        $hash2{$key} = $value;
    }
    return(\%hash2);
}

sub mkkeys {
    my $hash = shift;
    my %hash2;
    for my $key (keys(%$hash)){
        $hash2{$key} = $hash->{$key};
    }
    return(\%hash2);
}

sub mksort {
    my $hash = shift;
    my %hash2;
    foreach my $key (sort keys %$hash) {
        $hash2{$key} = $hash->{$key};
    }
    return(\%hash2);
}

my %hash = (name => 'name1', surname => 'surname1', address => 'address', var => 'var1', var2 => 'var2');

Benchmark::cmpthese(1000000, {
    'Keys' => sub { mkkeys(\%hash) },
    'Each' => sub { mkeach(\%hash) },
    'Sort' => sub { mksort(\%hash) },
});

Benchmark::timethese(1000000, {
    'Keys' => sub { mkkeys(\%hash) },
    'Each' => sub { mkeach(\%hash) },
    'Sort' => sub { mksort(\%hash) },
});

        Rate Each Sort Keys
Each 66800/s   --  -3% -14%
Sort 68681/s   3%   -- -11%
Keys 77459/s  16%  13%   --
Benchmark: timing 1000000 iterations of Each, Keys, Sort...
      Each: 16 wallclock secs (14.92 usr +  0.00 sys = 14.92 CPU) @ 67024.13/s (n=1000000)
      Keys: 12 wallclock secs (12.91 usr +  0.00 sys = 12.91 CPU) @ 77459.33/s (n=1000000)
      Sort: 15 wallclock secs (14.62 usr +  0.00 sys = 14.62 CPU) @ 68399.45/s (n=1000000)

That’s all for now, but I’ll continue to optimize my code so I think there will be an updates soon.

To figure out whether perl module is installed at the system. Run:

perl -M<module_name> -e 1

if command return an error or NOT 0(zero) then module is not installed at the moment.

Here is also perl script which help you check a lot of modules:

#!/usr/local/bin/perl

my @modules = qw (put your modules here separated by space without any quotes);

foreach my $module (@modules){
print $module,"\t";
my $result=system("perl -M$module -e 1");
print "Installed" if (!$result);
print "\n";
}

EOF

My Perl script require several things :

1. Perl interpreter of course
2. IO::Socket perl module
3. Getopt::Long perl module

I will tell you nothing about first one. To install perl modules run cpan as root:

cpan -i Getopt::Long

and

cpan -i IO::Socket

When installation will be finished. Download bandtest.pl and save it at 1-st server.

Now go to the second one and run netcat(please make sure you have this package installed):

server02# nc -4tl 7777 > /dev/null

You can use any free port instead port 7777.

Back to first server and run bandtest.pl, but before make sure there is no any firewalls rules which hamper in connection between to hosts on port 7777.

Use telnet to check connection:

server01# telnet server02 7777
Connected to kivras01.
Escape character is '^]'.

This output means connection is successfully opened, so you can continue.

Make file with size for example 100Mb(I advice you to don’t use very big files, 100Mb is fit size which doesn’t fill your memory out and enough for proper results. I intentionally put file into memory before sending the data’s. This allow me delete any I/O operation during the network connection and as result prevent any result distortion.):

server01# dd if=/dev/zero of=/tmp/test bs=1024 count=1000000
100000+0 records in
100000+0 records out
102400000 bytes (102 MB) copied, 1.20234 s, 85.2 MB/s

Run bandtest.pl to get a results:

server01$ ./bandtest.pl -h server02 -p 7777 -f /tmp/test
Bytes were transfered 102.40 MB
Seconds taken: 8
Average speed 12.80 MB

EOF.

First of all you need to get Google KEY, to do this you should have google account. If you have it visit google key page to generate the map key.

After you’ve done it -> you will be ready for next steps.

Below the script should be downloaded in your html directory as location.cgi for example:

#!/usr/bin/perl                                              

use strict;
use LWP;   

sub GetCode {
 my ($map_key,$lat,$long,$zoom)=@_;

 my $head = <<HEAD;
 <title>Your current location</title>
 <script src="http://maps.google.com/maps?file=api&amp;v=2&amp;sensor=false&amp;key=$map_key"
 type="text/javascript"></script>
 <script type="text/javascript">
 function initialize() {
 if (GBrowserIsCompatible()) {
 var map = new GMap2(document.getElementById("map_canvas"));
 map.setCenter(new GLatLng($lat, $long), $zoom);
 map.setUIToDefault();
 }
 }
 </script>
HEAD
 my $body= <<BODY;
 <body onload="initialize()" onunload="GUnload()">
 Your current location is $ENV{REMOTE_ADDR}:<br>
 <div id="map_canvas" style="width: 500px; height: 300px"></div>
 </body>
BODY
return($head,$body);
}                                                                                                

sub GetHTMLCode {
 my ($head,$body)=@_;
 my $html = <<HTML;
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml">
 <head>
 <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
 $head
 </head>
 $body
HTML
 return $html;
}

sub GetCoordinates {
 my $ip = shift;
 my ($lat,$long);
 my $ua = new LWP::UserAgent;
 $ua->agent("Opera/9.0 " . $ua->agent);
 $ua->timeout("5");

 my $req = new HTTP::Request( GET => "http://www.geobytes.com/IpLocator.htm?GetLocation&template=php3.txt&IpAddress=$ip");
 my $res = $ua->request($req);
 if (! $res->is_success) {
 die "can't get acccess to server \n";
 }
 my $content=$res->content;
 foreach my $str (split(/\n/,$content)){
 $lat = $1 if ($str =~ /meta name=.latitude. content=.(\d+\.\d+)./);
 $long = $1 if ($str =~ /meta name=.longitude. content=.(\d+\.\d+)./);
 }
 return($long,$lat);
}
my $map_key="";
my $zoom="10";
my $ip_addr=$ENV{REMOTE_ADDR};
my ($long,$lat)=GetCoordinates($ip_addr);
my ($head,$body)=GetCode($map_key,$lat,$long,$zoom);
my $html = GetHTMLCode($head,$body);
print "Content-type: text/html\n\n";
print $html;

This script also available by this link.
Your google key should be defined as variable map_key in the code.

Function GetCode – return two values:

1. $head – this block should be put into the <head> section of your html code.
2. $body – into the <body> section.

Function GetCoordinates return longitude and latitude of got ip.

Function  GetHTMLCode was used to generate example html code.

You also can implement these functions into your page as module. Download google_map.pm and save it in your perl modules directory or do it as describe in this post. After, you can easily call this functions from your code as show below:

#!/usr/bin/perl

use lib "path/to/directory/where/you/save/google_map.pm";
require google_map;

my $map_key="your_map_key_was_described_below";
my $zoom="10";
my $ip_addr=$ENV{REMOTE_ADDR};
my ($long,$lat)=google_map::GetCoordinates($ip_addr);
my ($head,$body)=google_map::GetCode($map_key,$lat,$long,$zoom);
my $html = google_map::GetHTMLCode($head,$body);
print "Content-type: text/html\n\n";
print $html;

To see how it work check this link out.

Perl module PadWalker is require. Install it over cpan util:

cpan -i PadWalker 

Let’s create simple script:

$cat ./hello.pl

#!/usr/bin/perl
sub say_hello {
my $what=shift;
print "Hello $what\n";
}

my $var1="var1";
my $var2="var2";
say_hello("you");
my $var3="var3";

And try to debug it:

$ perl -dF hello.pl

Loading DB routines from perl5db.pl version 1.31
Editor support available.Enter h or `h h' for help, or `man perldebug' for more help.main::(hello.pl:8):     say_hello("you");
DB<1>

type “h” to get help. To list a function use “l function_name”:

 DB<1> l say_hello
3       sub say_hello {
4:              my $what=shift;
5:              print "Hello $what\n";
6       }

To make step without entry to function use “n”. To go through function “s”

 DB<2> s
main::say_hello(hello.pl:4):            my $what=shift;

To return from subroutine use “r”.

use “y” to print all variables and their values or use “y variable” to print specific.

 DB<1> y
$var1 = 'var1'
$var2 = 'var2'

and

DB<1> y var1
$var1 = 'var1'

Options “M” print all used modules and path to them:

 DB<2> M
'AutoLoader.pm' => '5.67 from /usr/local/lib/perl5/5.8.9/AutoLoader.pm'
'Carp.pm' => '1.10 from /usr/local/lib/perl5/5.8.9/Carp.pm'
...

“R” – restart the scripts.

“V” – list variables

“S” – list subroutine

“q” – for exit

1. Get module and install it to directory where you have write permission (For example: /home/user1/libs).
2. Go to your script and add new library path to your INC array:

use lib '/home/user1/libs';

to check that it was successfully put in INC array, print it out

print "\@INC = @INC\n";

3. Include it to your script with “require” or “use” directives.

require "test.pm";

or

use "test.pm";

SAMPLE

Here is some little sample how it’s work.

Our module:

user1@agrytsenko:~/tmp2$ cat lib/test.pm
package test;

use strict;

sub say {
my $word=shift;
my $str="Hello my $word world\n";
return($str);
}
1;
__END__

Our script:

user1@agrytsenko:~/tmp2$ cat bin/test.pl
#!/usr/bin/perl

use lib '/home/user1/tmp2/lib';
require 'test.pm';

my $string=test::say("good");
print $string, "\n";

Our running result:

sheva@agrytsenko:~/tmp2/bin$ ./test.pl
Hello my good world

To run it on your box you should have perl interpreter and some perl modules. Such as:

LWP::UserAgent
Getopt::Long

You can get it directly from site or over the cpan util as well. The source of script here You have to put it on your computer. Also you need get the list of proxy(It can be easily done by google, just type “anonymous proxy list” and you will get a lot of links). Take list and put into the file. Like this :

agrytsenko:~/tmp$ cat proxy.2
64.66.192.61:80 0.8680  Transp. US      Y       65%     2008-12-04 09:51:23
89.114.36.221:8000      1.0750  Elite   RO      ?       30%     2008-12-04 09:39:18
74.65.65.195:8000       1.1030  Elite   US      Y       47%     2008-12-04 09:40:49
89.97.128.86:6588       1.1630  Elite   IT      N       33%     2008-12-04 09:37:52
200.179.72.132:80       1.1830  Transp. BR      Y       91%     2008-12-04 09:51:23
207.182.129.90:3128     1.2570  Transp. US      Y       54%     2008-12-04 09:51:23
207.182.129.91:3128     1.2850  Transp. US      Y       57%     2008-12-04 09:51:23
66.98.152.157:6654      1.4750  Elite   US      Y       11%     2008-12-04 09:37:52
92.48.119.220:6654      1.6100  Elite   GB      Y       29%     2008-12-04 09:36:26

or like this:

agrytsenko:~/tmp$ cat proxy
64.66.192.61:80
150.101.196.52:3128
114.30.47.10:80
114.127.246.36

The main rule of file format: the first field has to be ip:port of proxy.

The script has several keys. Here they are:

agrytsenko:~/tmp$ ./proxy_checker.pl -h
-f file         Specify file
-v              Turn on verbose mode
-h              Print this help

Okay, now you are ready to run it:

agrytsenko:~/tmp$ ./proxy_checker.pl -f ./proxy -v
Try to open proxy list ./proxy
Connect to site over 64.66.192.61:80...
Connection was not established. The reason is :
500 Can't connect to 64.66.192.61:80 (connect: timeout)

Connect to site over 150.101.196.52:3128...
Success connected with IP=150.101.196.52
Proxy 150.101.196.52:3128 is avaible for connections
The 150.101.196.52:3128 is not fully anonymous. You ip address is 79.124.129.220

Connect to site over 114.30.47.10:80...
Connection was not established. The reason is :
503 Service Unavailable

Connect to site over 114.127.246.36:8080...
Success connected with IP=114.127.246.36
Proxy 114.127.246.36:8080 is avaible for connections

As you can see we have only one fully anonymous proxy for now. It’s 114.127.246.36.

Done.

Week ago I start to read book about Linux clustering. When I learned about high available cluster I have decided to made some script which will be able to implement it.

THEORY:
We have 2 Linux machine, local network, Internet connection and border gateway.

As you can see at Figure.1.
Node1 and Node2 have internal IPs 10.0.30.1 and 10.0.30.2 respectively. Default route has ip 10.0.30.254. And it provide PAT(Port Address Translation) support . In other words translates all request from internet web clients to web server into localnet virtual ip 10.0.30.3 which always assigned to active node. I will skip how to install PAT support but share my knowledge’s in rest part of project.

PRACTICE:
First of all we need machine with preinstalled Linux OS, web server, rsync and ssh. In this example I used CentOS and apache but it does not metter.

Try to build network connections.
Network configuration for Node #1 :

#cat /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE=eth0
HWADDR=08:00:27:7B:7E:03
ONBOOT=yes
IPADDR=10.0.30.2
GATEWAY=10.0.30.254

For node #2:

#cat /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE=eth0
HWADDR=08:00:27:B9:50:94
ONBOOT=yes
IPADDR=10.0.30.1

GATEWAY=10.0.30.254

In next step you need to enable rsync in xinted config:

#cat /etc/xinetd.d/rsync
service rsync
{
        disable = no
        socket_type     = stream
        wait            = no
        user            = root
        server          = /usr/bin/rsync
        server_args     = --daemon
        log_on_failure  += USERID
}

And restart it:

/etc/init.d/xinted restart

Also you need to enable some SELinux bool:

#setsebool -P rsync_export_all_ro=on

Add user rsync in group root for both nods and generate ssh keys for they. Below described step-by-step actions:

For Node #1 :
Add user:

#useradd -g root rsycn 

Login as rsync

#su - rsync 

Generate new rsa key:

#ssh-keygen -t rsa -b 2048 -f rsync.key

When ssh-keygen asks you to provide passprase. Hit Enter twice to get non-password access in the future.

Copy public key to the remote host:

#scp rsync.key.pub root@10.0.30.2:/root/.ssh

For node #2 :

#useradd -g root rsycn
#mv ~/.ssh/rsync.key.pub  ~rsync/.ssh/authorized_keys
#chown rsync ~rsync/.ssh/authorized_keys
#chmod 600 ~rsync/.ssh/authorized_keys
#su - rsync
#ssh-keygen -t rsa -b 2048 -f rsync.key
#scp rsync.key.pub root@10.0.30.1:/root

Back to Node #1 and perform next actions:

#mv ~/rsync.key.pub  ~rsync/.ssh/authorized_keys
#chown rsync ~rsync/.ssh/authorized_keys
#chmod 600 ~rsync/.ssh/authorized_keys

To check if the keys and rsync works properly. Run this on Node #2:

#rsycn -e ssh rsync@10.0.30.1:/var/www/html /var/www/

After that if you have done everything right. The web files from Node #1 should be transfered to your local web directory.

Let’s check our config file:

#cat node.conf
another_node_addr=10.0.30.1
# this is comment
virtual_addr=10.0.30.3
max_sleep_time=10
max_ping_cnt=5
log_facility=local6
debug=1

All lines begging from “#” interpreted as a comments. Therefore it’s ignored by script.

another_node_addr – defined internal ip of other node
virtual_addr – defined common virtual ip for both node
max_sleep_time – max value for sleep(in seconds) between pings
max_ping_cnt – max amount of ping attempts
log_facility – the syslog facility for the logging
sycn_time – time for syncronization web documents from master to slave web-server. “d” – for day, “h” – hours, “min” – minutes, “mon” – months. For example:
sync_time=50min – means that files have to be syncronized every 50 minutes.
debug – the value “1″ is turn on debug

Be careful the maximum migration time you can calculate in next way:
max_sleep_time*(max_ping_cnt+1)+crontab ,
by default it’s 10*(5+1)= 60 + 60 (crontab) =120 seconds.

Download main script and config file and put these into the your nodes.

You can see a little bit of explanation about how to script works in block scheme below.

After these steps you are ready to tune your syslog and crontab configuration. Actions described below should be done on both node’s.
Put into the /etc/syslog.conf:

log_facility.*                                                -/var/log/node.log

Where log_facility is log facility defined at node.conf.

Put this into crontab to make script run by crontab every minute:

#crontab -e
*/1 * * * *     /PATH/TO/check_node.pl /PATH/TO/node.conf

I suppost it will be worked for you as well as for me.
The End.

Set “rotation_period” by days at variable section to define log rotation period. Set to “0″ if you want to turn off rotation.

NOTICE: This script works only if perl interpreter is available on web server. You can check it in next way:
$ perl -v

Copyright 1987-2006, Larry Wall


You can view and download it from here.

This script should be put into the web server. My web-hoster doesn’t allow me send mail through shell. That’s why all lines concerning mail issue are commented out in my script. In case your hoster provides you this feature you can use it after drop comments and define variables related to mail.

Don’t forget to put script in the crontab. It’s should be executed at the end of the day:
$ crontab -l
# DO NOT EDIT THIS FILE - edit the master and reinstall.
# (/tmp/crontab.XXXXQpChAn installed on Sun Jun 14 21:56:42 2009)
# (Cron version V5.0 -- $Id: crontab.c,v 1.12 2004/01/23 18:56:42 vixie Exp $)
HOME=/home/virtwww/w_andriigrytse-net_9c210a4f
SHELL=/bin/bash
MAILTO=w_andriigrytse-net_9c210a4f

59 23 * * * $HOME/stat.pl


Good luck:)

To make it works you have to install next perl libraries :

Net::SSH::Expect;
Net::SCP::Expect;
Net::SFTP::Foreign;
Net::FTP;

It’s easy to do through cpan. For example:

# cpan i Net::SSH::Expect

or download directly from cpan

function exec_cmd__ :

This function execute command at remote host. Example:

exec_cmd__(hostname, username, password, port, command)

function sub transfer_file__ :

This function can get or put file to remote host via ssh. Example :

transfer_file__(hostname, username, password, port, source file|directory, destination file|directory, method)

where option “method” can be “fh”(means get file from somewhere and put to localhost) or “th”(send file to host)

function sub sftp_func__ :

This function can get and send file to remote computer via sftp protocol. Example
sftp_func__(hostname, username, password, port, source file|directory, destination file|directory, method)

Where option “method” can be ‘get’(get file from remote host) and ‘put’(put file to remote host) and ‘del’(delete file from remote host )
NOTICE: if you use method “del” please specify the target as “source_file” and skip “destination_file” option

function ftp_func__ :

This function get and delete remote file via ftp protocol. Example:

ftp_func__(hostname, username, password, port, source file|directory, destination file|directory, method)
where option “method” can be ‘get’ or ‘put’

function get_file_via_ftp__:

This function is the same to previous one EXCEPT its doesn’t put a file at remote computer and when its get a file doesn’t remove it at remote system. Example:

get_file_via_ftp(hostname, username, password, port, source file|directory, destination file|directory)

function get_yesterday__:

This function return date of yesterday in format which was got by function as first argument. Example:

get_yesterday__(”YYYYDDMM”), get_yesterday__(”DDMMYYYY”) and so on.

How it’s use? Good question :)

Download this library and put into the /usr/lib/perl5/Net/. Ex.:

# cp monitoring.pm /usr/lib/perl5/Net/

Create new test script :
$ cat > test.pl
#!/usr/bin/perl
use monitoring;
$yesterday=monitoring::get_yesterday__("DDMMYYYY");
print "$yesterday\n";


Set executable rights:
$ chmod +x test.pl

And run it:
$ ./test.pl
11062009

That’s all :)