#!/usr/bin/env perl
 
#-------------
#--- MODEL ---
#-------------
 
package PGagent::Model;
 
use strict;
use warnings;
use File::stat;
use Data::Dumper;
use DBI;
use Mojo::UserAgent;
use POSIX;
use Socket;
 
sub new {
    my ($class, $app, $pghost, $username, $password) = @_;
    my $self = {
        app => $app,
        pghost => $pghost,
        dsn => "dbi:Pg:dbname=postgres;host=$pghost",
        username => $username,
        password => $password,
    };
    bless $self, $class;
    return $self;
}
 
sub username { 
    return shift->{username}; 
}
sub password { 
    return shift->{password}; 
}
sub dsn { 
    return shift->{dsn}; 
}
sub pghost { 
    return shift->{pghost}; 
}
sub app { 
    return shift->{app}; 
}
 
 
sub storeAlive {
    my ($self, $hostname) = @_;
    return undef unless $hostname;
    my $ua = Mojo::UserAgent->new(max_redirects => 2) or return undef;
    my $tx = $ua->get("http://$hostname:3002/hello");
    my $res;
    eval { $res = decode_json($tx->result->body); };
    return 1;# if $res->{'message'} eq 'hello';
    return undef;
}
 
sub storePut {
    my ($self, $datafile, $storename, $storeuser, $storepwd) = @_;
    my $ua = Mojo::UserAgent->new(max_redirects => 5);
    return undef unless $datafile;
    return undef unless $storename;
 
    return undef unless -f $datafile;
    return undef unless -r $datafile;
    return undef unless $self->storeAlive($storename);
 
    $self->app->log->info(" --- Start upload $datafile to store $storename");
    my $tx = $ua->post("http://$storeuser:$storepwd\@$storename:3002/store/put" =>
                            form => { data => { file => $datafile }} );
    $self->app->log->info(" --- End upload $datafile to store $storename");
 
    my $res;
    eval { $res = $tx->result; };
    return $res->body if $res;
    return undef;
}
 
# ---- agent::model db* ---
sub dbExist {
    my ($self, $dbname) = @_;
    return undef unless $dbname;
    my $dblist = $self->dbList;
    foreach my $db (@{$dblist}) {
        return 1 if $db->{"name"} eq $dbname;
    }
    return undef;
}
 
sub dbSize {
    my ($self, $dbname) = @_;
    return undef unless $dbname;
    return -1 unless $self->dbExist($dbname);
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return -1;
    my $query = "select pg_database_size('$dbname');";
    my $sth = $db->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_array;
    $sth->finish;
    $db->disconnect;
    my $dbsize = int($row);
    return $dbsize;
}
 
sub dbList {
    my $self = shift;
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return -1;
    my $query = "select d.datname as name, pg_database_size(d.datname) as size, u.usename as owner 
                    from pg_database d, pg_user u where d.datdba = u.usesysid;";
    my $sth = $db->prepare($query);
    my $rows = $sth->execute  or return -1;
    my @dblist;
    while (my $row = $sth->fetchrow_hashref) {
        push @dblist, $row;
    }
    $sth->finish;
    $db->disconnect;
    return \@dblist;
}
 
sub dbCreate {
    my ($self, $dbname) = @_;
    return undef unless $dbname;
    return 1 if $self->dbExist($dbname);
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "create database $dbname;";
    my $rows = $db->do($query) or return undef;
    $db->disconnect;
    return 1 if $rows;
    return undef;
}
 
sub dbDrop {
    my ($self, $dbname) = @_;
    return undef unless $self->dbExist($dbname);
    return undef unless $dbname;
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "drop database $dbname;";
    my $rows = $db->do($query);
    $db->disconnect;
    return 1 if $rows;
    return undef;
}
 
sub dbRename {
    my ($self, $dbname, $newname) = @_;
    return undef unless $self->dbExist($dbname);
    return undef unless $dbname;
    return undef unless $newname;
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "alter database $dbname rename to $newname;";
    my $rows = $db->do($query);
    $db->disconnect;
    return 1 if $rows;
    return undef;
}
 
sub dbCopy {
    my ($self, $dbname, $newname) = @_;
    return undef unless $dbname;
    return undef unless $newname;
    return undef unless $self->dbExist($dbname);
    return undef if $self->dbExist($newname);
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "create database $newname template $dbname;";
    my $rows = $db->do($query) or return undef;
    $db->disconnect;
    return 1 if $rows;
    return undef;
}
 
 
sub dbDump {
    my ($self, $dbname) = @_;
 
    return undef unless $dbname;
    return undef unless $self->dbExist($dbname);
 
    my $workdir = "/".$self->app->config("workdir");
 
    do {
        $self->app->log->info("Error: Workdir $workdir not exist");
        return undef; 
    } unless -d $workdir;
    do {
        $self->app->log->info("Error: Cannot write to workdir $workdir");
        return undef; 
    } unless -w $workdir;
 
    my $hostname = $self->app->config("hostname");
    my $timestamp = strftime("%Y%m%d-%H%M%S-%Z", localtime(time));
    my $dbdump = "$workdir/$dbname--$timestamp--$hostname.sqlz";
 
    my $password = $self->password;
    my $pghost = $self->pghost;
    my $username = $self->username;
 
    my $dbsize = $self->dbSize($dbname);
 
    $self->app->log->info("--- Start dump database $dbname with db size $dbsize");
    my $out = qx/PGPASSWORD=$password pg_dump -h $pghost -U $username -Fc -f $dbdump $dbname 2>&1/;
    my $retcode = $?;
 
    my $dumpstat = stat($dbdump);
    my $dumpsize = $dumpstat->size;
    $self->app->log->info("--- End dump database $dbname to $dbdump with size $dumpsize");
 
    return $dbdump if $retcode == 0;
    return undef;
}
 
 
 
#select d.datname as dbname, u.usename as username from pg_database d, pg_user u where d.datdba = u.usesysid order by dbname;
 
sub dbOwner {
    my ($self, $dbname) = @_;
    return undef unless $dbname;
    return undef unless $self->dbExist($dbname);
 
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "select u.usename as username, d.datname as dbname 
                        from pg_database d, pg_user u 
                        where d.datdba = u.usesysid and d.datname = '$dbname' limit 1;";
    my $sth = $db->prepare($query);
    my $rows = $sth->execute  or return undef;
    my $row = $sth->fetchrow_hashref;
    $db->disconnect;
    return $row if $row;
    return undef;
}
 
sub roleList {
    my ($self) = @_;
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "select usename as rolename from pg_user;";
    my $sth = $db->prepare($query);
    my $rows = $sth->execute  or return undef;
    my @rolelist;
    while (my $row = $sth->fetchrow_hashref) {
        push @rolelist, $row;
    }
    $sth->finish;
    $db->disconnect;
    return \@rolelist;
}
 
sub roleExist {
    my ($self, $rolename) = @_;
    return undef unless $rolename;
    my $rolelist = $self->roleList;
    foreach my $role (@{$rolelist}) {
        return 1 if $rolename eq $role->{'rolename'};
    }
    return undef;
}
 
 
sub roleCreate {
    my ($self, $rolename, $password) = @_;
    return undef unless $password;
    return undef unless $rolename;
    return undef unless $self->roleExist($rolename);
 
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "create user '$rolename' encrypted password '$password';";
    my $rows = $db->do($query);
    $db->disconnect;
 
    return 1 if $rows;
    return undef;
}
 
sub roleDrop {
    my ($self, $rolename) = @_;
    return 1;
}
 
sub rolePassword {
    my ($self, $rolename, $password) = @_;
    return undef unless $password;
    return undef unless $rolename;
    return undef unless $self->roleExist($rolename);
 
    my $db = DBI->connect($self->dsn, $self->username, $self->password) or return undef;
    my $query = "alter role $rolename encrypted password '$password';";
    my $rows = $db->do($query);
    $db->disconnect;
 
    return 1 if $rows;
    return undef;
}
 
 
1;
 
#------------------
#--- CONTROLLER ---
#------------------
 
package PGagent::Controller;
 
use utf8;
use strict;
use warnings;
use Mojo::Base 'Mojolicious::Controller';
use Mojo::Util qw(dumper);
use Mojo::JSON qw(encode_json decode_json);
use Mojo::IOLoop::Subprocess;
use Apache::Htpasswd;
 
sub hello {
    my $self = shift;
    $self->render(json => { message => 'hello' } );
}
 
sub confDump {
    my $self = shift;
    $self->render(json => $self->app->config);
}
 
sub dbList {
    my $self = shift;
    $self->render(json => { dblist => $self->app->model->dbList } );
}
 
sub dbSize {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $dbname;
    my $dbsize = $self->app->model->dbSize($dbname);
    $self->render(json => { name => $dbname, size => $dbsize });
}
 
sub dbCreate {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $dbname;
    my $res = $self->app->model->dbCreate($dbname);
    return $self->render(json => { result => "success", dbname => $dbname }) if $res;
    return $self->render(json => { result => "mistake", dbname => $dbname });
}
 
sub dbDrop {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $dbname;
    my $res = $self->app->model->dbDrop($dbname);
    return $self->render(json => { result => "success", dbname => $dbname }) if $res;
    return $self->render(json => { result => "mistake", dbname => $dbname });
}
 
sub dbRename {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
    my $newname = $self->req->param('newname');
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $dbname;
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $newname;
    my $res = $self->app->model->dbRename($dbname, $newname);
    my $dbsize = $self->app->model->dbSize($dbname) if $res;
    return $self->render(json => {result => "success", dbname => $dbname, dbsize => $dbsize}) if $res;
    return $self->render(json => { result => "mistake", dbname => $dbname });
}
 
 
sub dbCopy {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
    my $newname = $self->req->param('newname');
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $dbname;
    return $self->render(json => { result => "mistake", dbname => $dbname }) unless $newname;
    my $res = $self->app->model->dbCopy($dbname, $newname);
    my $dbsize = $self->app->model->dbSize($dbname) if $res;
    return $self->render(json => {result => "success", dbname => $dbname, dbsize => $dbsize}) if $res;
    return $self->render(json => { result => "mistake", dbname => $dbname });
}
 
sub dbExist {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
    return $self->render(json => { result => "mistake", dbname => '' }) unless $dbname;
    my $res = $self->app->model->dbExist($dbname);
    my $dbsize = $self->app->model->dbSize($dbname) if $res;
    return $self->render(json => { result => "success", dbname => $dbname, dbsize => $dbsize}) if $res;
    return $self->render(json => { result => "mistake", dbname => $dbname });
}
 
sub dbDump {
    my $self = shift;
    my $dbname = $self->req->param('dbname');
 
    my $storename = $self->req->param('store');
    my $storelogin = $self->req->param('storelogin');
    my $storepwd = $self->req->param('storepwd');
 
    my $master = $self->req->param('master');
    my $jobid = $self->req->param('jobid');
    my $magic = $self->req->param('magic');
 
    return $self->render(json => { response => "mistake", dbname => '' }) unless $dbname;
    return $self->render(json => { response => "mistake", dbname => $dbname }) 
            unless $self->app->model->dbExist($dbname);
 
##    my $res = $self->app->model->dbDump($dbname);
 
    my $subprocess = Mojo::IOLoop::Subprocess->new;
    $self->app->log->info(" -- Begin dump database $dbname in subprocess"); 
    $subprocess->run(
        sub {
            my $subprocess = shift;
            my $filename = $self->app->model->dbDump($dbname);
            do { unlink $filename; return undef; } unless $filename;
            my $storeRes = $self->app->model->storePut($filename, $storename, $storelogin, $storepwd);
            do { unlink $filename; return undef; } unless $storeRes;
            unlink $filename;
            return 1;
        },
        sub {
            my ($subprocess, $err, @results) = @_;
            my $pid = $subprocess->pid;
            $self->app->log->info(" -- End dump subprocess $pid for dump database $dbname");
        }
    );
    $subprocess->ioloop->start unless $subprocess->ioloop->is_running;
    $self->render(json => { result => "success", $dbname => $dbname } );
}
 
sub roleList {
    my $self = shift;
    $self->render(json => { result => "success", role => $self->app->model->roleList } );
}
 
sub roleExist {
    my $self = shift;
    my $rolename = $self->req->param('rolename');
    return $self->render(json => { result => "mistake", rolename => undef } )  unless $rolename;
    my $res = $self->app->model->roleExist($rolename);
    return $self->render(json => { result => "success", rolename => $rolename } ) if $res;
    $self->render(json => { result => "mistake", rolename => $rolename } );
}
 
sub rolePassword {
    my $self = shift;
    my $rolename = $self->req->param('rolename');
    return $self->render(json => { result => "mistake", rolename => undef } )  unless $rolename;
    $self->render(json => { result => "success", rolename => $rolename } );
}
 
sub roleCreate {
    my $self = shift;
    my $rolename = $self->req->param('rolename');
    return $self->render(json => { result => "mistake", rolename => undef } )  unless $rolename;
    $self->render(json => { result => "success", rolename => $rolename } );
}
 
sub roleDrop {
    my $self = shift;
    my $rolename = $self->req->param('rolename');
    return $self->render(json => { result => "mistake", rolename => undef } )  unless $rolename;
    $self->render(json => { result => "success", rolename => $rolename } );
}
 
1;
 
#------------
#--- APP ---
#------------
 
package PGagent;
 
use utf8;
use strict;
use warnings;
use Mojo::Base 'Mojolicious';
 
sub startup {
    my $self = shift;
}
 
1;
 
#------------
#--- MAIN ---
#------------
 
use strict;
use warnings;
use utf8;
 
use Mojo::Server::Prefork;
use Mojo::IOLoop::Subprocess;
use Mojo::Util qw(monkey_patch b64_encode b64_decode md5_sum getopt dumper);
use Sys::Hostname qw(hostname);
use File::Basename qw(basename dirname);
use Apache::Htpasswd;
use Cwd qw(getcwd abs_path);
 
my $appfile = abs_path(__FILE__);
my $appdir = dirname($appfile);
my $appname = dirname($appfile).'/'.basename($appfile, ".pl");
$0 = $appname;
 
my $server = Mojo::Server::Prefork->new;
my $app = $server->build_app('PGagent');
 
my $wd = getcwd;
 
$app->config(
        hostname => hostname,
        workdir => "/data/pgagent",
        listenIPv4 => "0.0.0.0",
        listenIPv6 => "[::]",
        listenPort => "3001",
        pghost => "127.0.0.1",
        pguser => "postgres",
        pgpasswd => "password",
        pwdfile => "$appname.pw",
        pidfile => "$appname.pid",
        logfile => "$appname.log",
        conffile => "$appname.conf",
);
 
my $conffile = $app->config('conffile');
do {
    $app->log->debug("Load configuration from $conffile ");
    my $config = $app->plugin( 'JSONConfig', { file => $conffile } );
} if -r $conffile;
 
$app->helper(
    model => sub {
        state $model = PGagent::Model->new(
            $app,
            $app->config("pghost"),
            $app->config("pguser"),
            $app->config("pgpasswd")
        );
    }
);
 
my $r = $app->routes;
 
$r->add_condition(
    auth => sub {
        my ($route, $c, $captures, $hash) = @_;
        my $authStr = $c->req->headers->authorization;
        return undef unless $authStr;
 
        my ($authType, $encAuthPair) = split / /, $authStr;
        return undef unless ($authType eq 'Basic' && $encAuthPair);
 
        my ($username, $password) = split /:/, b64_decode($encAuthPair);
        $c->app->log->debug("Receive auth pair: '$username:$password'");
        return undef unless ($username && $password);
 
        my $passwdFile = $c->app->config('pwdfile');
        my $result = undef;
        eval {
            my $ht = Apache::Htpasswd->new($passwdFile);
            $result = $ht->htCheckPassword($username, $password);
        };
        do { $c->app->log->debug($@); return undef; } if $@;
        return 1 if $result;
        return undef;
    }
);
 
$r->any('/hello')->to('Controller#hello');
$r->any('/db/list')->to('Controller#dbList');
$r->any('/db/create')->to('Controller#dbCreate');
$r->any('/db/drop')->to('Controller#dbDrop');
$r->any('/db/rename')->to('Controller#dbRename');
$r->any('/db/copy')->to('Controller#dbCopy');
$r->any('/db/size')->to('Controller#dbSize');
$r->any('/db/dump')->to('Controller#dbDump');
$r->any('/db/exist')->to('Controller#dbExist');
$r->any('/conf/dump')->to('Controller#confDump');
 
$r->any('/db/owner')->to('Controller#dbOwner');
 
$r->any('/role/list')->to('Controller#roleList');
$r->any('/role/exist')->to('Controller#roleExist');
$r->any('/role/password')->to('Controller#rolePassword');
$r->any('/role/create')->to('Controller#roleCreate');
$r->any('/role/drop')->to('Controller#roleDrop');
 
#$app->mode($app->config("mode"));
$app->secrets([ md5_sum(localtime(time)) ]);
 
$app->hook(before_dispatch => sub {
        my $c = shift;
        my $remoteIP = $c->tx->remote_address;
        $c->app->log->info($remoteIP.' '.$c->req->method.' '.$c->req->url->to_abs->to_string);
});
 
$app->helper('reply.exception' => sub { my $c = shift; return $c->rendered(404); });
$app->helper('reply.not_found' => sub { my $c = shift; return $c->rendered(404); });
 
$server->listen([
    "http://".$app->config("listenIPv4").":".$app->config("listenPort"),
    "http://".$app->config("listenIPv6").":".$app->config("listenPort")
]);
 
$server->heartbeat_interval(3);
$server->heartbeat_timeout(60);
$server->pid_file($app->config('pidfile'));
 
 
my $daemon = 0;
 
if ($daemon) {
    my $pid = fork;
    if ($pid == 0) {
#        setuid($appUID) if $appUID;
#        setgid($appGID) if $appGID;
        $app->log(Mojo::Log->new( path => $app->config('logfile') ));
        open (my $STDOUT2, '>&', STDOUT); open (STDOUT, '>>', '/dev/null');
        open (my $STDERR2, '>&', STDERR); open (STDERR, '>>', '/dev/null');
        chdir($appdir);
        local $SIG{HUP} = sub {
                $app->log->info('Catch HUP signal'); 
                $app->log(Mojo::Log->new(path => $app->config('logfile')));
        };
        $server->run;
    }
} else {
#    setuid($appUID) if $appUID;
#    setgid($appGID) if $appGID;
    $server->run;
}
#EOF

#!/usr/bin/env perl
 
package PGmaster::Model;
 
use strict;
use warnings;
use File::stat;
use DBI;
use Mojo::UserAgent;
use Mojo::JSON qw(encode_json decode_json);
use Mojo::Util qw(md5_sum dumper);
use Socket;
use POSIX;
 
 
sub new {
    my ($class, $app, $dbhost, $dbuser, $dbpasswd, $dbname) = @_;
    my $self = {
        app => $app,
        dbhost => $dbhost,
        dsn => "dbi:Pg:dbname=$dbname;host=$dbhost",
        dbuser => $dbuser,
        dbpasswd => $dbpasswd,
        dbname => $dbname
    };
    bless $self, $class;
    return $self;
}
 
sub dbuser { 
    return shift->{dbuser}; 
}
 
sub dbpasswd { 
    return shift->{dbpasswd}; 
}
 
sub dsn { 
    return shift->{dsn}; 
}
 
sub dbhost { 
    return shift->{dbhost}; 
}
 
sub app { 
    return shift->{app}; 
}
 
sub hostnameAlive {
    my ($self, $hostname) = @_;
    return undef unless gethostbyname($hostname);
    return 1;
}
 
sub parseLabel {
    my ($self, $label) = @_;
    return undef unless $label;
 
    $label =~ s/.sqlz$//;
 
    my ($dbname, $Y, $M, $D, $h, $m, $s, $tz, $host) = 
        $label =~ /([_a-z0-9]{1,64})--([0-9]{4})([0-9]{2})([0-9]{2})-([0-9]{2})([0-9]{2})([0-9]{2})-([A-Z]{2,3})--([_\-a-zA-Z0-9\.]{1,64})/g;
 
    my %data;
    $data{'dbname'} = $dbname;
    $data{'timestamp'} = "$Y-$M-$D $h:$m:$s $tz";
    $data{'source'} = $host;
    return \%data;
}
 
sub timestamp {
    my $self = shift;
    return strftime("%Y-%m-%d %H:%M:%S %Z", localtime(time));
}
 
sub sizeHR {
    my ($self, $size) = @_;
    return $size if $size < 1024;
    return int($size/1024+0.5)."k" if ($size < 1024*1024 && $size > 1024);
    return int($size/(1024*1024)+0.5)."M" if ($size < 1024*1024*1024 && $size > 1024*1024);
    return int($size/(1024*1024*1024)+0.5)."G" if ($size < 1024*1024*1024*1024 && $size > 1024*1024*1024);
}
 
sub sizeWP {
    my ($self, $size) = @_;
    my $out = $size;
    $out =~ s/(\d{9})$/.$1/g if $size > 1000*1000*1000;
    $out =~ s/(\d{6})$/.$1/g if $size > 1000*1000;
    $out =~ s/(\d{3})$/.$1/g if $size > 1000;
    return $out;
}
 
sub sizeR {
    my ($self, $size) = @_;
    return int($size/(1024*1024)+0.5);
}
 
 
#--- model::agent ---
 
sub agentList {
    my ($self, $id)  = @_;
    my $where = '';
    $where = "where id = $id" if $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select * from agent $where order by hostname;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
 
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
sub agentExist {
    my ($self, $hostname)  = @_;
    return undef unless $hostname;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id from agent where hostname = '$hostname' limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    my $id = $row->{'id'};
    return $id if $id;
    return undef;
}
 
sub agentHostname {
    my ($self, $id)  = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select hostname from agent where id = $id limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    my $hostname = $row->{'hostname'};
    return $hostname if $hostname;
    return undef;
}
 
sub agentProfile {
    my ($self, $id)  = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select * from agent where id = $id limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    return $row if $row;
    return undef;
}
 
sub agentNextID {
    my $self = shift;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id from agent order by id desc limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    my $id = $row->{'id'};
    $id++;
    $sth->finish;
    $dbi->disconnect;
    return $id;
}
 
sub agentAdd {
    my ($self, $hostname, $username, $password) = @_;
    return undef unless $hostname;
    return undef unless $username;
    return undef unless $password;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd) 
         or return undef;
    my $id = $self->agentNextID;
    my $query = "insert into agent (id, hostname, username, password) 
                    values ($id, '$hostname', '$username', '$password');";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $id if $rows*1 > 0;
    return undef;
}
 
sub agentDelete {
    my ($self, $id) = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "delete from agent where id = $id;";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $rows*1;
}
 
sub agentUpdate {
    my ($self, $id, $hostname, $username, $password) = @_;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "update agent set
                    hostname = '$hostname',
                    username = '$username',
                    password = '$password'
                    where id = $id;";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $rows*1;
}
 
sub agentAlive {
    my ($self, $id) = @_;
    return undef unless $id;
    my $hostname = $self->agentHostname($id) or return undef;
    my $ua = Mojo::UserAgent->new(max_redirects => 2) or return undef;
 
    my $tx = $ua->get("http://$hostname:3001/hello");
    my $res;
    eval { $res = decode_json($tx->result->body); };
    return 1 if  $res->{'message'} eq 'hello';
    return undef;
}
 
sub agentDBList {
    my ($self, $id) = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select * from db where agentid = $id order by name;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
sub agentDBUpdate {
    my ($self, $id) = @_;
    return undef unless $id;
#    my $dblist = $self->agentDBList($id);
    my $hostname = $self->agentHostname($id) or return undef;
    my $ua = Mojo::UserAgent->new(max_redirects => 2) or return undef;
    my $tx = $ua->get("http://$hostname:3001/db/list");
 
 
    my $res;
    eval { $res = decode_json($tx->result->body); };
    return undef if $@;
 
    my $dblist = $res->{'dblist'};
 
    return undef unless $dblist;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "delete from db where agentid = $id;";
    my $rows = $dbi->do($query) or return undef;
    return undef unless $rows;
    foreach my $rec (@{$dblist}) { 
        my $dbname = $rec->{'name'};
        my $dbsize = $rec->{'size'};
        my $dbowner = $rec->{'owner'};
        my $query = "insert into db (agentid, name, size, owner, type) values
                    ($id, '$dbname',  $dbsize, '$dbowner', 'pgsql');";
        my $rows = $dbi->do($query) or return undef;
    }
    $dbi->disconnect;
    return $dblist;
}
 
 
# --- model::store ---
 
sub storeHostname {
    my ($self, $id)  = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select hostname from store where id = $id limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    my $hostname = $row->{'hostname'};
    return $hostname if $hostname;
    return undef;
}
 
sub storeProfile {
    my ($self, $id)  = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select * from store where id = $id limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    return $row if $row;
    return undef;
}
 
sub storeAlive {
    my ($self, $id) = @_;
    return undef unless $id;
    my $hostname = $self->storeHostname($id) or return undef;
    my $ua = Mojo::UserAgent->new(max_redirects => 2) or return undef;
    my $tx = $ua->get("http://$hostname:3002/hello");
    my $res;
    eval { $res = decode_json($tx->result->body); };
    return 1 if  $res->{'message'} eq 'hello';
    return undef;
}
 
sub storeList {
    my ($self, $id)  = @_;
    my $where = '';
    $where = "where id = '$id'" if $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd);
    my $query = "select * from store $where order by hostname;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
 
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
sub storeExist {
    my ($self, $hostname)  = @_;
    return undef unless $hostname;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id from store where hostname = '$hostname' limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    my $id = $row->{'id'};
    return $id if $id;
    return undef;
}
 
sub storeNextID {
    my $self = shift;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd);
    my $query = "select id from store order by id desc limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    my $id = $row->{'id'};
    $id++;
    $sth->finish;
    $dbi->disconnect;
    return $id;
}
 
sub storeAdd {
    my ($self, $hostname, $username, $password) = @_;
    return undef unless $hostname;
    return undef unless $username;
    return undef unless $password;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $id = $self->storeNextID;
    my $query = "insert into store (id, hostname, username, password) 
                    values ($id, '$hostname', '$username', '$password');";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $id if $rows*1 > 0;
    return undef;
}
 
sub storeDelete {
    my ($self, $id) = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "delete from store where id = $id;";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $rows*1;
}
 
sub storeUpdate {
    my ($self, $id, $hostname, $username, $password) = @_;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "update store set
                    hostname = '$hostname',
                    username = '$username',
                    password = '$password'
                    where id = $id;";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $rows*1;
}
 
sub storeDataList {
    my ($self, $id) = @_;
    return undef unless $id;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select * from data where storeid = $id order by name;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
sub storeDataUpdate {
    my ($self, $id) = @_;
    return undef unless $id;
    my $hostname = $self->storeHostname($id) or return undef;
 
    my $ua = Mojo::UserAgent->new(max_redirects => 2) or return undef;
    my $tx = $ua->get("http://$hostname:3002/store/list");
 
    my $res = undef;
    eval { $res = decode_json($tx->result->body); };
    return undef if $@;
 
    my $datalist = $res->{'datalist'};
 
    return undef unless $datalist;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "delete from data where storeid = $id;";
    my $rows = $dbi->do($query) or return undef;
    return undef unless $rows;
 
    my @list;
    foreach my $rec (@{$datalist}) { 
        my $dataname = $rec->{'name'};
        my $datasize = $rec->{'size'};
        my $datamtime = $rec->{'mtime'};
 
        # Dataname pattern for dumps dbname--timestamp--sourcehost.ext
        next unless $dataname =~ m/.+--.+--.+\.(sqlz|sql|sql.gz|sql.xz)/;
 
        my $label = $self->app->model->parseLabel($dataname);
        my $dbname = $label->{'dbname'} || 'undef';
        my $source = $label->{'source'} || 'undef';
        my $stamp = $label->{'timestamp'} || '1970-01-01 00:00:00 UTC';
 
        my $query = "insert into data (storeid, name, size, mtime, type, dbname, source, stamp) values
                    ($id, '$dataname',  $datasize, '$datamtime', 'pgsql', '$dbname', '$source', '$stamp');";
        my $rows = $dbi->do($query) or return undef;
        push @list, $rec;
    }
    $dbi->disconnect;
    return \@list;
}
 
sub storeDataFree {
};
 
sub dataList {
    my $self = shift;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select s.hostname as store, d.* from data d, store s where s.id = d.storeid order by d.dbname;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
 
sub jobList {
    my $self = shift;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select * from job order by id;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
# --- model::job ----
 
sub jobCreate {
    my ($self, @args) = @_;
 
    my $id = $self->jobNextID;
 
    my $begin = strftime("%Y-%m-%d %H:%M:%S %Z", localtime(time));
    my $stop = '1970-01-01 00:00:00 UTC';
    my $type = "undef";
    my $author = "undef";
    my $sourceid = 0;
    my $destid = 0;
    my $status = "undef";
    my $error = "undef";
    my $message = "Job record created";
    my $magic = md5_sum(localtime(time));
 
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd) 
         or return undef;
    my $query = "insert into job (id, begin, stop, author, type, sourceid, destid, status, error, message, magic) 
                    values ($id, '$begin', '$stop', '$author', '$type', $sourceid, $destid, '$status', '$error', '$message', '$magic');";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $id if $rows*1 > 0;
    return undef;
}
 
 
sub jobList {
    my $self = shift;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id, 
                    to_char(begin, 'YYYY-MM-DD HH24:MI:SS TZ') as begin,
                    to_char(stop, 'YYYY-MM-DD HH24:MI:SS TZ') as stop,
                    author, type, sourceid, destid, status, error, message, magic from job 
                        order by id desc limit 100;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my @list;
    while (my $row = $sth->fetchrow_hashref) {
        push @list, $row;
    }
    $sth->finish;
    $dbi->disconnect;
    return \@list;
}
 
sub jobNextID {
    my $self = shift;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id from job order by id desc limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    my $id = $row->{'id'};
    $id++;
    $sth->finish;
    $dbi->disconnect;
    return $id;
}
 
sub jobExist {
    my ($self, $id)  = @_;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id from job where id = $id limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    $id = $row->{'id'};
    return $id if $id;
    return undef;
}
 
 
sub jobUpdate {
    my ($self, $id, %args) = @_;
 
    return undef unless $id;
    return undef unless $self->jobExist($id);
 
    my $jobProfile = $self->jobProfile($id);
    my $args = \%args;
    my $begin = $args->{'begin'} || $jobProfile->{'begin'};
    my $stop = $args->{'stop'} || $jobProfile->{'stop'};
    my $type = $args->{'type'} || $jobProfile->{'type'};
    my $author = $args->{'author'} || $jobProfile->{'author'};
    my $sourceid = $args->{'sourceid'} || $jobProfile->{'sourceid'};
    my $destid = $args->{'destid'} || $jobProfile->{'destid'};
 
    my $status = $args->{'status'} || $jobProfile->{'status'};
    my $error = $args->{'error'} || $jobProfile->{'error'};
    my $message = $args->{'message'} || $jobProfile->{'message'};
 
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "update job set
                    begin = '$begin',
                    stop = '$stop',
                    author = '$author',
                    type = '$type',
                    sourceid = $sourceid,
                    destid = $destid,
                    status = '$status',
                    error = '$error',
                    message = '$message'
                        where id = $id;";
 
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $id if $rows;
    return undef;
}
 
sub jobDelete {
    my ($self, $id) = @_;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "delete from job where id = $id;";
    my $rows = $dbi->do($query) or return undef;
    $dbi->disconnect;
    return $rows if $rows;
    return undef;
}
 
sub jobProfile {
    my ($self, $id)  = @_;
    my $dbi = DBI->connect($self->dsn, $self->dbuser, $self->dbpasswd)
        or return undef;
    my $query = "select id, to_char(begin, 'YYYY-MM-DD HH24:MI:SS TZ') as begin,
                    to_char(stop, 'YYYY-MM-DD HH24:MI:SS TZ') as stop,
                    author, type, sourceid, destid, status, error, message, magic from job where id = $id limit 1;";
    my $sth = $dbi->prepare($query);
    my $rows = $sth->execute;
    my $row = $sth->fetchrow_hashref;
    $sth->finish;
    $dbi->disconnect;
    return $row if $row;
    return undef;
}
 
 
1;
 
#------------------
#--- CONTROLLER ---
#------------------
 
package PGmaster::Controller;
 
use utf8;
use strict;
use warnings;
use Mojo::Base 'Mojolicious::Controller';
use Mojo::Util qw(md5_sum dumper);
use Mojo::JSON qw(encode_json decode_json);
 
sub hello {
    my $self = shift;
    $self->render(template => 'hello');
 
#    my $id = $self->app->model->jobCreate;
#    my $idn = $self->app->model->jobUpdate($id, status => 'AAAAAAAAAAAAAAA!!!', type => 'OOOOOOOOOOOO!');
#    my $job = $self->app->model->jobProfile($id);
#
#    my $list = $self->app->model->jobList;
#    $self->render(text => dumper($list));
}
 
 
#--- controller::agent ---
 
sub agentList {
    my $self = shift;
    $self->render(template => 'agentList');
}
 
sub agentFormAdd {
    my $self = shift;
    $self->render(template => 'agentFormAdd');
}
 
sub agentFormUpdate {
    my $self = shift;
    $self->render(template => 'agentFormUpdate', req => $self->req);
}
 
sub agentAdd {
    my $self = shift;
    $self->render(template => 'agentAdd', req => $self->req);
}
 
sub agentUpdate {
    my $self = shift;
    $self->render(template => 'agentUpdate', req => $self->req);
}
 
sub agentDelete {
    my $self = shift;
    $self->render(template => 'agentDelete', req => $self->req);
}
 
sub agentAlive {
    my $self = shift;
    my $id = $self->req->param('id');
    $self->render(template => 'agentAlive', req => $self->req);
}
 
sub agentDBList {
    my $self = shift;
    my $id = $self->req->param('id');
    $self->render(template => 'agentDBList', req => $self->req);
}
 
sub agentDBUpdate {
    my $self = shift;
    $self->render(template => 'agentDBUpdate', req => $self->req);
}
 
# --- controller::store ----
 
sub storeList {
    my $self = shift;
    $self->render(template => 'storeList');
}
 
sub storeFormAdd {
    my $self = shift;
    $self->render(template => 'storeFormAdd');
}
 
sub storeFormUpdate {
    my $self = shift;
    $self->render(template => 'storeFormUpdate', req => $self->req);
}
 
sub storeAdd {
    my $self = shift;
    $self->render(template => 'storeAdd', req => $self->req);
}
 
sub storeUpdate {
    my $self = shift;
    $self->render(template => 'storeUpdate', req => $self->req);
}
 
sub storeDelete {
    my $self = shift;
    $self->render(template => 'storeDelete', req => $self->req);
}
 
sub storeDataList {
    my $self = shift;
    my $id = $self->req->param('id');
    $self->render(template => 'storeDataList', req => $self->req);
}
 
sub storeDataUpdate {
    my $self = shift;
    $self->render(template => 'storeDataUpdate', req => $self->req);
}
 
# ---- controller::db req handlers---
 
sub dbCreate {
    my $self = shift;
    $self->render(template => 'dbCreate', req => $self->req);
}
 
sub dbDrop {
    my $self = shift;
    $self->render(template => 'dbDrop', req => $self->req);
}
 
sub dbRename {
    my $self = shift;
    $self->render(template => 'dbRename', req => $self->req);
}
 
sub dbCopy {
    my $self = shift;
    $self->render(template => 'dbCopy', req => $self->req);
}
 
sub dbDump {
    my $self = shift;
    $self->render(template => 'dbDump', req => $self->req);
}
 
sub dbRestore {
    my $self = shift;
    $self->render(template => 'dbRestore', req => $self->req);
}
 
sub dataList {
    my $self = shift;
    $self->render(template => 'dataList', req => $self->req);
}
 
sub jobList {
    my $self = shift;
    $self->render(template => 'jobList', req => $self->req);
}
 
1;
#-----------
#--- APP ---
#-----------
package PGmaster;
 
use utf8;
use strict;
use warnings;
use Mojo::Base 'Mojolicious';
 
sub startup {
    my $self = shift;
}
 
1;
#------------
#--- MAIN ---
#------------
use strict;
use warnings;
use utf8;
 
use Mojo::Server::Prefork;
use Mojo::IOLoop::Subprocess;
use Mojo::Util qw(monkey_patch b64_encode b64_decode md5_sum getopt dumper);
use File::Basename;
use Sys::Hostname qw(hostname);
 
my $server = Mojo::Server::Prefork->new;
my $appname = basename(__FILE__, ".pl");
my $workdir = dirname(__FILE__);
 
my $app = $server->build_app('PGmaster');
 
$app->config(
    hostname => hostname,
    libdir => "$workdir",
    pidfile => "$appname.pid",
    logfile => "$appname.log",
    mode => "production",
    dbhost => "127.0.0.1",
    dbname => "dumper",
    dbuser => "postgres",
    dbpasswd => "password"
);
 
$app->helper(
    model => sub {
        state $model = PGmaster::Model->new(
            $app,
            $app->config("dbhost"),
            $app->config("dbuser"),
            $app->config("dbpasswd"),
            $app->config("dbname"),
        );
    }
);
 
# --- log all request ---
$app->hook(before_dispatch => sub {
        my $c = shift;
        my $remoteIP = $c->tx->remote_address;
        $c->app->log->debug($remoteIP.' '.$c->req->method.' '.$c->req->url->to_abs->to_string);
});
 
# --- log target request ---
$app->hook(after_render => sub {
        my ($c, $output, $format) = @_;
        my $remote_ip = $c->tx->remote_address;
        my $method = $c->req->method;
 
#        $c->app->log->info($remote_ip.' '.$c->req->method.' '.$c->req->url->to_abs->to_string);
 
        my $base = $c->req->url->base->to_string;
        my $path = $c->req->url->path->to_string;
        $c->app->log->info('Processed '.$remote_ip.' '.$method.' '.$base.''.$path);
});
 
$app->max_request_size(1024*1024*1024);
$app->moniker($appname);
#$app->mode('production');
$app->secrets([ md5_sum(localtime(time)) ]);
#$app->log(Mojo::Log->new(path => $app->config('logfile')));
 
$app->static->paths->[0] = $app->config('libdir').'/public';
$app->renderer->paths->[0] = $app->config('libdir').'/templs';
 
my $r = $app->routes;
 
$r->any('/db/create')->to('Controller#dbCreate');
$r->any('/db/drop')->to('Controller#dbDrop');
$r->any('/db/copy')->to('Controller#dbCopy');
$r->any('/db/rename')->to('Controller#dbRename');
$r->any('/db/dump')->to('Controller#dbDump');
$r->any('/db/restore')->to('Controller#dbRestore');
 
 
$r->any('/hello')->to('Controller#hello');
$r->any('/agent/list')->to('Controller#agentList');
$r->any('/agent/form/add')->to('Controller#agentFormAdd');
$r->any('/agent/form/update')->to('Controller#agentFormUpdate');
$r->any('/agent/add')->to('Controller#agentAdd');
$r->any('/agent/update')->to('Controller#agentUpdate');
$r->any('/agent/delete')->to('Controller#agentDelete');
$r->any('/agent/alive')->to('Controller#agentAlive');
 
$r->any('/agent/dblist')->to('Controller#agentDBList');
$r->any('/agent/dbupdate')->to('Controller#agentDBUpdate');
 
$r->any('/store/list')->to('Controller#storeList');
$r->any('/store/form/add')->to('Controller#storeFormAdd');
$r->any('/store/form/update')->to('Controller#storeFormUpdate');
$r->any('/store/add')->to('Controller#storeAdd');
$r->any('/store/update')->to('Controller#storeUpdate');
$r->any('/store/delete')->to('Controller#storeDelete');
 
$r->any('/store/datalist')->to('Controller#storeDataList');
$r->any('/store/dataupdate')->to('Controller#storeDataUpdate');
 
$r->any('/db/create')->to('Controller#dbCreate');
$r->any('/db/drop')->to('Controller#dbDrop');
$r->any('/db/copy')->to('Controller#dbCopy');
$r->any('/db/rename')->to('Controller#dbRename');
$r->any('/db/dump')->to('Controller#dbDump');
$r->any('/db/restore')->to('Controller#dbRestore');
 
$r->any('/data/list')->to('Controller#dataList');
$r->any('/job/list')->to('Controller#jobList');
 
$server->listen(["http://0.0.0.0:3000"]);
 
$server->pid_file($app->config('pidfile'));
 
$server->heartbeat_interval(3);
$server->heartbeat_timeout(60);
 
$server->run;
#EOF