data/PVE/Daemon.pm

   1 package PVE::Daemon;
   2
   3 # Abstract class to implement Daemons
   4 #
   5 # Features:
   6 # * lock and write PID file /var/run/$name.pid to make sure onyl
   7 #   one instance is running.
   8 # * correctly daemonize (redirect STDIN/STDOUT)
   9 # * restart by stop/start, exec, or signal HUP
  10 # * daemon restart on error (option 'restart_on_error')
  11 # * handle worker processes (option 'max_workers')
  12
  13 use strict;
  14 use warnings;
  15 use PVE::SafeSyslog;
  16 use PVE::INotify;
  17
  18 use POSIX ":sys_wait_h";
  19 use Fcntl ':flock';
  20 use Getopt::Long;
  21 use Time::HiRes qw (gettimeofday);
  22
  23 use base qw(PVE::CLIHandler);
  24
  25 $ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
  26
  27 my $daemon_initialized = 0; # we only allow one instance
  28
  29 my $close_daemon_lock = sub {
  30     my ($self) = @_;
  31
  32     return if !$self->{daemon_lock_fh};
  33
  34     close $self->{daemon_lock_fh};
  35     delete $self->{daemon_lock_fh};
  36 };
  37
  38 my $log_err = sub {
  39     my ($msg) = @_;
  40     chomp $msg;
  41     print STDERR "$msg\n";
  42     syslog('err', "%s", $msg);
  43 };
  44
  45 # call this if you fork() from child
  46 # Note: we already call this for workers, so it is only required
  47 # if you fork inside a simple daemon (max_workers == 0).
  48 sub after_fork_cleanup {
  49     my ($self) = @_;
  50
  51     &$close_daemon_lock($self);
  52
  53     PVE::INotify::inotify_close();
  54
  55     for my $sig (qw(CHLD HUP INT TERM QUIT)) {
  56         $SIG{$sig} = 'DEFAULT'; # restore default handler
  57         # AnyEvent signals only works if $SIG{XX} is
  58         # undefined (perl event loop)
  59         delete $SIG{$sig}; # so that we can handle events with AnyEvent
  60     }
  61 }
  62
  63 my $lockpidfile = sub {
  64     my ($self) = @_;
  65
  66     my $lkfn = $self->{pidfile} . ".lock";
  67
  68     my $waittime = 0;
  69
  70     if (my $fd = $self->{env_pve_lock_fd}) {
  71
  72         $self->{daemon_lock_fh} = IO::Handle->new_from_fd($fd, "a");
  73
  74     } else {
  75
  76         $waittime = 5;
  77         $self->{daemon_lock_fh} = IO::File->new(">>$lkfn");
  78     }
  79
  80     if (!$self->{daemon_lock_fh}) {
  81         die "can't open lock '$lkfn' - $!\n";
  82     }
  83
  84     for (my $i = 0; $i < $waittime; $i ++) {
  85         return if flock ($self->{daemon_lock_fh}, LOCK_EX|LOCK_NB);
  86         sleep(1);
  87     }
  88
  89     if (!flock ($self->{daemon_lock_fh}, LOCK_EX|LOCK_NB)) {
  90         &$close_daemon_lock($self);
  91         my $err = $!;
  92
  93         my ($running, $pid) = $self->running();
  94         if ($running) {
  95             die "can't aquire lock '$lkfn' - daemon already started (pid = $pid)\n";
  96         } else {
  97             die "can't aquire lock '$lkfn' - $err\n";
  98         }
  99     }
 100 };
 101
 102 my $writepidfile = sub {
 103     my ($self) = @_;
 104
 105     my $pidfile = $self->{pidfile};
 106
 107     die "can't open pid file '$pidfile' - $!\n" if !open (PIDFH, ">$pidfile");
 108
 109     print PIDFH "$$\n";
 110     close (PIDFH);
 111 };
 112
 113 my $server_cleanup = sub {
 114     my ($self) = @_;
 115
 116     unlink $self->{pidfile} . ".lock";
 117     unlink $self->{pidfile};
 118 };
 119
 120 my $finish_workers = sub {
 121     my ($self) = @_;
 122
 123     foreach my $cpid (keys %{$self->{workers}}) {
 124         my $waitpid = waitpid($cpid, WNOHANG);
 125         if (defined($waitpid) && ($waitpid == $cpid)) {
 126             delete ($self->{workers}->{$cpid});
 127             syslog('info', "worker $cpid finished");
 128         }
 129     }
 130 };
 131
 132 my $start_workers = sub {
 133     my ($self) = @_;
 134
 135     return if $self->{terminate};
 136
 137     my $count = 0;
 138     foreach my $cpid (keys %{$self->{workers}}) {
 139         $count++;
 140     }
 141
 142     my $need = $self->{max_workers} - $count;
 143
 144     return if $need <= 0;
 145
 146     syslog('info', "starting $need worker(s)");
 147
 148     while ($need > 0) {
 149         my $pid = fork;
 150
 151         if (!defined ($pid)) {
 152             syslog('err', "can't fork worker");
 153             sleep (1);
 154         } elsif ($pid) { # parent
 155             $self->{workers}->{$pid} = 1;
 156             syslog('info', "worker $pid started");
 157             $need--;
 158         } else {
 159             $0 = "$self->{name} worker";
 160
 161             $self->after_fork_cleanup();
 162
 163             eval { $self->run(); };
 164             if (my $err = $@) {
 165                 syslog('err', $err);
 166                 sleep(5); # avoid fast restarts
 167             }
 168
 169             syslog('info', "worker exit");
 170             exit (0);
 171         }
 172     }
 173 };
 174
 175 my $terminate_server = sub {
 176     my ($self) = @_;
 177
 178     $self->{terminate} = 1; # set flag to avoid worker restart
 179
 180     if (!$self->{max_workers}) {
 181         eval { $self->shutdown(); };
 182         warn $@ if $@;
 183         return;
 184     }
 185
 186     eval { $self->shutdown(); };
 187     warn $@ if $@;
 188
 189     # we have workers - terminate them
 190
 191     foreach my $cpid (keys %{$self->{workers}}) {
 192         kill(15, $cpid); # TERM childs
 193     }
 194
 195     # nicely shutdown childs (give them max 10 seconds to shut down)
 196     my $previous_alarm = alarm(10);
 197     eval {
 198         local $SIG{ALRM} = sub { die "timeout\n" };
 199
 200         while ((my $pid = waitpid (-1, 0)) > 0) {
 201             if (defined($self->{workers}->{$pid})) {
 202                 delete($self->{workers}->{$pid});
 203                 syslog('info', "worker $pid finished");
 204             }
 205         }
 206         alarm(0); # avoid race condition
 207     };
 208     my $err = $@;
 209
 210     alarm ($previous_alarm);
 211
 212     if ($err) {
 213         syslog('err', "error stopping workers (will kill them now) - $err");
 214         foreach my $cpid (keys %{$self->{workers}}) {
 215             # KILL childs still alive!
 216             if (kill (0, $cpid)) {
 217                 delete($self->{workers}->{$cpid});
 218                 syslog("err", "kill worker $cpid");
 219                 kill(9, $cpid);
 220                 # fixme: waitpid?
 221             }
 222         }
 223     }
 224 };
 225
 226 my $server_run = sub {
 227     my ($self, $debug) = @_;
 228
 229     # fixme: handle restart lockfd
 230     &$lockpidfile($self);
 231
 232     # remove FD_CLOEXEC bit to reuse on exec
 233     $self->{daemon_lock_fh}->fcntl(Fcntl::F_SETFD(), 0);
 234
 235     $ENV{PVE_DAEMON_LOCK_FD} = $self->{daemon_lock_fh}->fileno;
 236
 237     # run in background
 238     my $spid;
 239
 240     $self->{debug} = 1 if $debug;
 241
 242     $self->init();
 243
 244     if (!$debug) {
 245         open STDIN,  '</dev/null' || die "can't read /dev/null";
 246         open STDOUT, '>/dev/null' || die "can't write /dev/null";
 247     }
 248
 249     if (!$self->{env_restart_pve_daemon} && !$debug) {
 250         PVE::INotify::inotify_close();
 251         $spid = fork();
 252         if (!defined ($spid)) {
 253             die "can't put server into background - fork failed";
 254         } elsif ($spid) { # parent
 255             exit (0);
 256         }
 257         PVE::INotify::inotify_init();
 258     }
 259
 260     if ($self->{env_restart_pve_daemon}) {
 261         syslog('info' , "restarting server");
 262     } else {
 263         &$writepidfile($self);
 264         syslog('info' , "starting server");
 265     }
 266
 267     POSIX::setsid();
 268
 269     open STDERR, '>&STDOUT' || die "can't close STDERR\n";
 270
 271     my $old_sig_term = $SIG{TERM};
 272     local $SIG{TERM} = sub {
 273         local ($@, $!, $?); # do not overwrite error vars
 274         syslog('info', "received signal TERM");
 275         &$terminate_server($self);
 276         &$server_cleanup($self);
 277         &$old_sig_term(@_) if $old_sig_term;
 278     };
 279
 280     my $old_sig_quit = $SIG{QUIT};
 281     local $SIG{QUIT} = sub {
 282         local ($@, $!, $?); # do not overwrite error vars
 283         syslog('info', "received signal QUIT");
 284         &$terminate_server($self);
 285         &$server_cleanup($self);
 286         &$old_sig_quit(@_) if $old_sig_quit;
 287     };
 288
 289     my $old_sig_int = $SIG{INT};
 290     local $SIG{INT} = sub {
 291         local ($@, $!, $?); # do not overwrite error vars
 292         syslog('info', "received signal INT");
 293         $SIG{INT} = 'DEFAULT'; # allow to terminate now
 294         &$terminate_server($self);
 295         &$server_cleanup($self);
 296         &$old_sig_int(@_) if $old_sig_int;
 297     };
 298
 299     $SIG{HUP} = sub {
 300         local ($@, $!, $?); # do not overwrite error vars
 301         syslog('info', "received signal HUP");
 302         if ($self->{max_workers}) {
 303             &$terminate_server($self);
 304             $self->{got_hup_signal} = 1;
 305         } elsif ($self->can('hup')) {
 306             eval { $self->hup() };
 307             warn $@ if $@;
 308         }
 309     };
 310
 311     eval {
 312         if ($self->{max_workers}) {
 313             my $old_sig_chld = $SIG{CHLD};
 314             local $SIG{CHLD} = sub {
 315                 local ($@, $!, $?); # do not overwrite error vars
 316                 &$finish_workers($self);
 317                 &$old_sig_chld(@_) if $old_sig_chld;
 318             };
 319
 320             for (;;) { # forever
 321                 &$start_workers($self);
 322                 sleep(5);
 323                 &$finish_workers($self);
 324                 last if $self->{terminate};
 325             }
 326
 327         } else {
 328             $self->run();
 329         }
 330     };
 331     my $err = $@;
 332
 333     if ($err) {
 334         syslog ('err', "ERROR: $err");
 335
 336         # fixme: kill all workers
 337
 338         if (my $wait_time = $self->{restart_on_error}) {
 339             $self->restart_daemon($wait_time);
 340         } else {
 341             $self->exit_daemon(-1);
 342         }
 343     }
 344
 345     if ($self->{got_hup_signal}) {
 346         $self->restart_daemon();
 347     } else {
 348         $self->exit_daemon(0);
 349     }
 350 };
 351
 352 sub new {
 353     my ($this, $name, $cmdline, %params) = @_;
 354
 355     die "missing name" if !$name;
 356
 357     initlog($name);
 358
 359     my $restart = $ENV{RESTART_PVE_DAEMON};
 360     delete $ENV{RESTART_PVE_DAEMON};
 361
 362     my $lockfd = $ENV{PVE_DAEMON_LOCK_FD};
 363     delete $ENV{PVE_DAEMON_LOCK_FD};
 364
 365     die "please run as root\n" if !$restart && ($> != 0);
 366
 367     die "can't create more that one PVE::Daemon" if $daemon_initialized;
 368     $daemon_initialized = 1;
 369
 370     PVE::INotify::inotify_init();
 371
 372     my $class = ref($this) || $this;
 373
 374     my $self = bless {
 375         name => $name,
 376         run_dir => '/var/run',
 377         env_restart_pve_daemon => $restart,
 378         env_pve_lock_fd => $lockfd,
 379         workers => {},
 380     }, $class;
 381
 382     foreach my $opt (keys %params) {
 383         my $value = $params{$opt};
 384         if ($opt eq 'restart_on_error') {
 385             $self->{$opt} = $value;
 386         } elsif ($opt eq 'stop_wait_time') {
 387             $self->{$opt} = $value;
 388         } elsif ($opt eq 'run_dir') {
 389             $self->{$opt} = $value;
 390         } elsif ($opt eq 'max_workers') {
 391             $self->{$opt} = $value;
 392         } else {
 393             die "unknown option '$opt'";
 394         }
 395     }
 396
 397     $self->{pidfile} = "$self->{run_dir}/${name}.pid";
 398
 399     $self->{nodename} = PVE::INotify::nodename();
 400
 401     $self->{cmdline} = [];
 402
 403     foreach my $el (@$cmdline) {
 404         $el =~ m/^(.*)$/; # untaint
 405         push @{$self->{cmdline}}, $1;
 406     }
 407
 408     $0 = $name;
 409
 410     return $self;
 411 }
 412
 413 sub exit_daemon {
 414     my ($self, $status) = @_;
 415
 416     syslog("info", "server stopped");
 417
 418     &$server_cleanup($self);
 419
 420     exit($status);
 421 }
 422
 423 sub restart_daemon {
 424     my ($self, $waittime) = @_;
 425
 426     syslog('info', "server shutdown (restart)");
 427
 428     $ENV{RESTART_PVE_DAEMON} = 1;
 429
 430     sleep($waittime) if $waittime; # avoid high server load due to restarts
 431
 432     PVE::INotify::inotify_close();
 433
 434     exec (@{$self->{cmdline}});
 435
 436     exit (-1); # never reached?
 437 }
 438
 439 # please overwrite in subclass
 440 # this is called at startup - before forking
 441 sub init {
 442     my ($self) = @_;
 443
 444 }
 445
 446 # please overwrite in subclass
 447 sub shutdown {
 448     my ($self) = @_;
 449
 450     syslog('info' , "server closing");
 451
 452     if (!$self->{max_workers}) {
 453         # wait for children
 454         1 while (waitpid(-1, POSIX::WNOHANG()) > 0);
 455     }
 456 }
 457
 458 # please define in subclass
 459 #sub hup {
 460 #    my ($self) = @_;
 461 #
 462 #    syslog('info' , "received signal HUP (restart)");
 463 #}
 464
 465 # please overwrite in subclass
 466 sub run {
 467     my ($self) = @_;
 468
 469     for (;;) { # forever
 470         syslog('info' , "server is running");
 471         sleep(5);
 472     }
 473 }
 474
 475 sub start {
 476     my ($self, $debug) = @_;
 477
 478     eval  { &$server_run($self, $debug); };
 479     if (my $err = $@) {
 480         &$log_err("start failed - $err");
 481         exit(-1);
 482     }
 483 }
 484
 485 my $read_pid = sub {
 486     my ($self) = @_;
 487
 488     my $pid_str = PVE::Tools::file_read_firstline($self->{pidfile});
 489
 490     return 0 if !$pid_str;
 491
 492     return 0 if $pid_str !~ m/^(\d+)$/; # untaint
 493
 494     my $pid = int($1);
 495
 496     return $pid;
 497 };
 498
 499 sub running {
 500     my ($self) = @_;
 501
 502     my $pid = &$read_pid($self);
 503
 504     if ($pid) {
 505         my $res = PVE::ProcFSTools::check_process_running($pid) ? 1 : 0;
 506         return wantarray ? ($res, $pid) : $res;
 507     }
 508
 509     return wantarray ? (0, 0) : 0;
 510 }
 511
 512 sub stop {
 513     my ($self) = @_;
 514
 515     my $pid = &$read_pid($self);
 516
 517     return if !$pid;
 518
 519     if (PVE::ProcFSTools::check_process_running($pid)) {
 520         kill(15, $pid); # send TERM signal
 521         # give some time
 522         my $wait_time = $self->{stop_wait_time} || 5;
 523         my $running = 1;
 524         for (my $i = 0; $i < $wait_time; $i++) {
 525             $running = PVE::ProcFSTools::check_process_running($pid);
 526             last if !$running;
 527             sleep (1);
 528         }
 529
 530         syslog('err', "server still running - send KILL") if $running;
 531
 532         # to be sure
 533         kill(9, $pid);
 534         waitpid($pid, 0);
 535     }
 536
 537     if (-f $self->{pidfile}) {
 538         eval {
 539             # try to get the lock
 540             &$lockpidfile($self);
 541             &$server_cleanup($self);
 542         };
 543         if (my $err = $@) {
 544             &$log_err("cleanup failed - $err");
 545         }
 546     }
 547 }
 548
 549 sub register_start_command {
 550     my ($self, $class, $description) = @_;
 551
 552     $class->register_method({
 553         name => 'start',
 554         path => 'start',
 555         method => 'POST',
 556         description => $description || "Start the daemon.",
 557         parameters => {
 558             additionalProperties => 0,
 559             properties => {
 560                 debug => {
 561                     description => "Debug mode - stay in foreground",
 562                     type => "boolean",
 563                     optional => 1,
 564                     default => 0,
 565                 },
 566             },
 567         },
 568         returns => { type => 'null' },
 569
 570         code => sub {
 571             my ($param) = @_;
 572
 573             $self->start($param->{debug});
 574
 575             return undef;
 576         }});
 577 }
 578
 579 my $reload_daemon = sub {
 580     my ($self, $use_hup) = @_;
 581
 582     if ($self->{env_restart_pve_daemon}) {
 583         $self->start();
 584     } else {
 585         my ($running, $pid) = $self->running();
 586         if (!$running) {
 587             $self->start();
 588         } else {
 589             if ($use_hup) {
 590                 syslog('info', "send HUP to $pid");
 591                 kill 1, $pid;
 592             } else {
 593                 $self->stop();
 594                 $self->start();
 595             }
 596         }
 597     }
 598 };
 599
 600 sub register_restart_command {
 601     my ($self, $class, $use_hup, $description) = @_;
 602
 603     $class->register_method({
 604         name => 'restart',
 605         path => 'restart',
 606         method => 'POST',
 607         description => $description || "Restart the daemon (or start if not running).",
 608         parameters => {
 609             additionalProperties => 0,
 610             properties => {},
 611         },
 612         returns => { type => 'null' },
 613
 614         code => sub {
 615             my ($param) = @_;
 616
 617             &$reload_daemon($self, $use_hup);
 618
 619             return undef;
 620         }});
 621 }
 622
 623 sub register_reload_command {
 624     my ($self, $class, $description) = @_;
 625
 626     $class->register_method({
 627         name => 'reload',
 628         path => 'reload',
 629         method => 'POST',
 630         description => $description || "Reload daemon configuration (or start if not running).",
 631         parameters => {
 632             additionalProperties => 0,
 633             properties => {},
 634         },
 635         returns => { type => 'null' },
 636
 637         code => sub {
 638             my ($param) = @_;
 639
 640             &$reload_daemon($self, 1);
 641
 642             return undef;
 643         }});
 644 }
 645
 646 sub register_stop_command {
 647     my ($self, $class, $description) = @_;
 648
 649     $class->register_method({
 650         name => 'stop',
 651         path => 'stop',
 652         method => 'POST',
 653         description => $description || "Stop the daemon.",
 654         parameters => {
 655             additionalProperties => 0,
 656             properties => {},
 657         },
 658         returns => { type => 'null' },
 659
 660         code => sub {
 661             my ($param) = @_;
 662
 663             $self->stop();
 664
 665             return undef;
 666         }});
 667 }
 668
 669 sub register_status_command {
 670     my ($self, $class, $description) = @_;
 671
 672     $class->register_method({
 673         name => 'status',
 674         path => 'status',
 675         method => 'GET',
 676         description => "Get daemon status.",
 677         parameters => {
 678             additionalProperties => 0,
 679             properties => {},
 680         },
 681         returns => {
 682             type => 'string',
 683             enum => ['stopped', 'running'],
 684         },
 685         code => sub {
 686             my ($param) = @_;
 687
 688             return $self->running() ? 'running' : 'stopped';
 689         }});
 690 }
 691
 692 1;
 693