lib/PXElator/daemons.pm

package daemons;

use warnings;
use strict;

use File::Slurp;
use Data::Dump qw/dump/;

use x11;
use store;

our $pids;
$pids = {
        httpd => $$,
        kvm => 'not started',
        wireshark => 'not started',
} unless defined $pids; # keep pids on refresh

sub DESTROY {
        warn "pids ",dump( $pids );
        foreach ( values %$pids ) {
                warn "kill $_";
                kill 1,$_ || kill 9, $_;
        }
}

$SIG{CHLD} = 'IGNORE';

sub audit {
        my $msg = shift;
        my $daemon = shift;
        store::audit( $msg, $daemon, { daemon => $daemon, message => $msg, @_ } );
}

mkdir "$server::conf/pid" unless -d "$server::conf/pid";

sub start_stop {
        my ($daemon,$param) = @_;

        if ( defined $param->{nr} ) { # XXX nr for kvm
                $daemon .= '.' . $param->{nr};
        } else {
                $param->{nr} = $1 if $daemon =~ /\.(\d+)/;
        }

        my $pid = $pids->{$daemon};
        my $pid_path = $daemon;
        $pid_path =~ s{/}{-}g;
        $pid_path = "$server::conf/pid/$pid_path";

        warn "# start_stop $daemon ",dump( $param );

        if ( ! $pid && -e $pid_path ) {
                my $p = read_file $pid_path;
                if ( kill 0, $p ) {
                        audit 'adopted', $daemon, pid => $p;
                        return $pids->{$daemon} = $p;
                } else {
                        audit 'not running', $daemon, pid => $p;
                        unlink $pid_path;
                }
        }

        $pid ||= 'not started';
        warn "start_stop $daemon $pid\n";

        if ( $pid =~ m{^\d+$} && kill 0, $pid ) {
                my $pstree = `pstree -p $pid`;
                my @pids = $pstree =~ m{\((\d+)\)}g;
                warn "pstree $pstree pids ",dump( @pids );
                foreach ( @pids ) {
                        warn "kill $_\n";
                        kill 1, $_;
                        if ( kill 0, $_ ) {
                                warn "kill 9 $_";
                                kill 9, $_;
                        }
                }
                $pids->{$daemon} = 'stopped';
                audit 'stopped', $daemon, pid => $pid;
                return qq|$daemon pid $pid stopped|;
        } else {

                $ENV{$_} = $param->{$_} foreach keys %$param;

                if ( $pid = fork ) {
                        # parent
                        $pids->{$daemon} = $pid;
                        write_file $pid_path, $pid;
                        audit 'forked', $daemon, pid => $pid;

                        delete $ENV{$_} foreach keys %$param; # cleanup enviroment

                        return qq|$daemon pid $pid started|;
                } elsif ( defined $pid ) {
                        # child
                        my $invoke = 'start';
                        $invoke = $1 if $daemon =~ s{/(.+)}{};
                        #warn "## ENV child ",dump( %ENV );
                        if ( $daemon =~ m{dhcpd|tftpd|dnsd|syslogd} ) {
                                my $exec = "perl -I$server::base_dir/lib -I$server::base_dir/lib/PXElator -M$daemon -e ${daemon}::${invoke}";
                                audit 'exec', $daemon, 'exec' => $exec;
                                x11::xterm( $daemon => $exec );
                        } else {
                                $daemon =~ s{\.\d+$}{} if defined $ENV{nr};
                                my $eval = $daemon . '::' . $invoke . '(' . dump( $param ) . ')';
                                audit 'eval', $daemon, 'eval' => $eval;
                                eval $eval;
                                audit 'error', $daemon, error => $@  if $@;
                        }
                        exit;
                } else {
                        audit 'error', $daemon, error => $!;
                        die "fork error $!";
                }
        }
}

1	dpavlin	185	package daemons;
2
3			use warnings;
4			use strict;
5
6			use File::Slurp;
7			use Data::Dump qw/dump/;
8
9			use x11;
10	dpavlin	482	use store;
11	dpavlin	185
12			our $pids;
13	dpavlin	225	$pids = {
14			httpd => $$,
15			kvm => 'not started',
16			wireshark => 'not started',
17			} unless defined $pids; # keep pids on refresh
18	dpavlin	185
19			sub DESTROY {
20			warn "pids ",dump( $pids );
21			foreach ( values %$pids ) {
22			warn "kill $_";
23			kill 1,$_ \|\| kill 9, $_;
24			}
25			}
26
27			$SIG{CHLD} = 'IGNORE';
28
29	dpavlin	208	sub audit {
30			my $msg = shift;
31			my $daemon = shift;
32	dpavlin	482	store::audit( $msg, $daemon, { daemon => $daemon, message => $msg, @_ } );
33	dpavlin	208	}
34
35	dpavlin	321	mkdir "$server::conf/pid" unless -d "$server::conf/pid";
36
37	dpavlin	185	sub start_stop {
38	dpavlin	390	my ($daemon,$param) = @_;
39	dpavlin	185
40	dpavlin	547	if ( defined $param->{nr} ) { # XXX nr for kvm
41			$daemon .= '.' . $param->{nr};
42			} else {
43			$param->{nr} = $1 if $daemon =~ /\.(\d+)/;
44			}
45	dpavlin	390
46	dpavlin	185	my $pid = $pids->{$daemon};
47	dpavlin	321	my $pid_path = $daemon;
48	dpavlin	225	$pid_path =~ s{/}{-}g;
49	dpavlin	321	$pid_path = "$server::conf/pid/$pid_path";
50	dpavlin	185
51	dpavlin	390	warn "# start_stop $daemon ",dump( $param );
52
53	dpavlin	185	if ( ! $pid && -e $pid_path ) {
54			my $p = read_file $pid_path;
55			if ( kill 0, $p ) {
56	dpavlin	208	audit 'adopted', $daemon, pid => $p;
57	dpavlin	185	return $pids->{$daemon} = $p;
58			} else {
59	dpavlin	208	audit 'not running', $daemon, pid => $p;
60	dpavlin	185	unlink $pid_path;
61			}
62			}
63
64			$pid \|\|= 'not started';
65			warn "start_stop $daemon $pid\n";
66
67	dpavlin	245	if ( $pid =~ m{^\d+$} && kill 0, $pid ) {
68	dpavlin	185	my $pstree = `pstree -p $pid`;
69			my @pids = $pstree =~ m{\((\d+)\)}g;
70			warn "pstree $pstree pids ",dump( @pids );
71	dpavlin	227	foreach ( @pids ) {
72			warn "kill $_\n";
73			kill 1, $_;
74			if ( kill 0, $_ ) {
75			warn "kill 9 $_";
76			kill 9, $_;
77			}
78			}
79	dpavlin	185	$pids->{$daemon} = 'stopped';
80	dpavlin	208	audit 'stopped', $daemon, pid => $pid;
81	dpavlin	185	return qq\|$daemon pid $pid stopped\|;
82			} else {
83	dpavlin	390
84			$ENV{$_} = $param->{$_} foreach keys %$param;
85
86	dpavlin	185	if ( $pid = fork ) {
87			# parent
88			$pids->{$daemon} = $pid;
89			write_file $pid_path, $pid;
90	dpavlin	208	audit 'forked', $daemon, pid => $pid;
91	dpavlin	390
92			delete $ENV{$_} foreach keys %$param; # cleanup enviroment
93
94	dpavlin	185	return qq\|$daemon pid $pid started\|;
95			} elsif ( defined $pid ) {
96			# child
97			my $invoke = 'start';
98			$invoke = $1 if $daemon =~ s{/(.+)}{};
99	dpavlin	398	#warn "## ENV child ",dump( %ENV );
100	dpavlin	231	if ( $daemon =~ m{dhcpd\|tftpd\|dnsd\|syslogd} ) {
101	dpavlin	185	my $exec = "perl -I$server::base_dir/lib -I$server::base_dir/lib/PXElator -M$daemon -e ${daemon}::${invoke}";
102	dpavlin	208	audit 'exec', $daemon, 'exec' => $exec;
103	dpavlin	185	x11::xterm( $daemon => $exec );
104			} else {
105	dpavlin	390	$daemon =~ s{\.\d+$}{} if defined $ENV{nr};
106			my $eval = $daemon . '::' . $invoke . '(' . dump( $param ) . ')';
107	dpavlin	208	audit 'eval', $daemon, 'eval' => $eval;
108	dpavlin	185	eval $eval;
109	dpavlin	208	audit 'error', $daemon, error => $@ if $@;
110	dpavlin	185	}
111			exit;
112			} else {
113	dpavlin	208	audit 'error', $daemon, error => $!;
114	dpavlin	185	die "fork error $!";
115			}
116			}
117			}
118