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     $name = 'daemon' if !$name; # should not happen
 356
 357     initlog($name);
 358
 359     my $self;
 360
 361     eval {
 362
 363         my $restart = $ENV{RESTART_PVE_DAEMON};
 364         delete $ENV{RESTART_PVE_DAEMON};
 365
 366         my $lockfd = $ENV{PVE_DAEMON_LOCK_FD};
 367         delete $ENV{PVE_DAEMON_LOCK_FD};
 368
 369         if (defined($lockfd)) {
 370             $lockfd =~ m/^(\d+)$/;
 371             $lockfd = $1; # untaint
 372         }
 373
 374         die "please run as root\n" if !$restart && ($> != 0);
 375
 376         die "can't create more that one PVE::Daemon" if $daemon_initialized;
 377         $daemon_initialized = 1;
 378
 379         PVE::INotify::inotify_init();
 380
 381         my $class = ref($this) || $this;
 382
 383         $self = bless {
 384             name => $name,
 385             run_dir => '/var/run',
 386             env_restart_pve_daemon => $restart,
 387             env_pve_lock_fd => $lockfd,
 388             workers => {},
 389         }, $class;
 390
 391         foreach my $opt (keys %params) {
 392             my $value = $params{$opt};
 393             if ($opt eq 'restart_on_error') {
 394                 $self->{$opt} = $value;
 395             } elsif ($opt eq 'stop_wait_time') {
 396                 $self->{$opt} = $value;
 397             } elsif ($opt eq 'run_dir') {
 398                 $self->{$opt} = $value;
 399             } elsif ($opt eq 'max_workers') {
 400                 $self->{$opt} = $value;
 401             } else {
 402                 die "unknown daemon option '$opt'\n";
 403             }
 404         }
 405
 406         $self->{pidfile} = "$self->{run_dir}/${name}.pid";
 407
 408         $self->{nodename} = PVE::INotify::nodename();
 409
 410         $self->{cmdline} = [];
 411
 412         foreach my $el (@$cmdline) {
 413             $el =~ m/^(.*)$/; # untaint
 414             push @{$self->{cmdline}}, $1;
 415         }
 416
 417         $0 = $name;
 418     };
 419     if (my $err = $@) {
 420         &$log_err($err);
 421         exit(-1);
 422     }
 423
 424     return $self;
 425 }
 426
 427 sub exit_daemon {
 428     my ($self, $status) = @_;
 429
 430     syslog("info", "server stopped");
 431
 432     &$server_cleanup($self);
 433
 434     exit($status);
 435 }
 436
 437 sub restart_daemon {
 438     my ($self, $waittime) = @_;
 439
 440     syslog('info', "server shutdown (restart)");
 441
 442     $ENV{RESTART_PVE_DAEMON} = 1;
 443
 444     sleep($waittime) if $waittime; # avoid high server load due to restarts
 445
 446     PVE::INotify::inotify_close();
 447
 448     exec (@{$self->{cmdline}});
 449
 450     exit (-1); # never reached?
 451 }
 452
 453 # please overwrite in subclass
 454 # this is called at startup - before forking
 455 sub init {
 456     my ($self) = @_;
 457
 458 }
 459
 460 # please overwrite in subclass
 461 sub shutdown {
 462     my ($self) = @_;
 463
 464     syslog('info' , "server closing");
 465
 466     if (!$self->{max_workers}) {
 467         # wait for children
 468         1 while (waitpid(-1, POSIX::WNOHANG()) > 0);
 469     }
 470 }
 471
 472 # please define in subclass
 473 #sub hup {
 474 #    my ($self) = @_;
 475 #
 476 #    syslog('info' , "received signal HUP (restart)");
 477 #}
 478
 479 # please overwrite in subclass
 480 sub run {
 481     my ($self) = @_;
 482
 483     for (;;) { # forever
 484         syslog('info' , "server is running");
 485         sleep(5);
 486     }
 487 }
 488
 489 sub start {
 490     my ($self, $debug) = @_;
 491
 492     eval  { &$server_run($self, $debug); };
 493     if (my $err = $@) {
 494         &$log_err("start failed - $err");
 495         exit(-1);
 496     }
 497 }
 498
 499 my $read_pid = sub {
 500     my ($self) = @_;
 501
 502     my $pid_str = PVE::Tools::file_read_firstline($self->{pidfile});
 503
 504     return 0 if !$pid_str;
 505
 506     return 0 if $pid_str !~ m/^(\d+)$/; # untaint
 507
 508     my $pid = int($1);
 509
 510     return $pid;
 511 };
 512
 513 sub running {
 514     my ($self) = @_;
 515
 516     my $pid = &$read_pid($self);
 517
 518     if ($pid) {
 519         my $res = PVE::ProcFSTools::check_process_running($pid) ? 1 : 0;
 520         return wantarray ? ($res, $pid) : $res;
 521     }
 522
 523     return wantarray ? (0, 0) : 0;
 524 }
 525
 526 sub stop {
 527     my ($self) = @_;
 528
 529     my $pid = &$read_pid($self);
 530
 531     return if !$pid;
 532
 533     if (PVE::ProcFSTools::check_process_running($pid)) {
 534         kill(15, $pid); # send TERM signal
 535         # give some time
 536         my $wait_time = $self->{stop_wait_time} || 5;
 537         my $running = 1;
 538         for (my $i = 0; $i < $wait_time; $i++) {
 539             $running = PVE::ProcFSTools::check_process_running($pid);
 540             last if !$running;
 541             sleep (1);
 542         }
 543
 544         syslog('err', "server still running - send KILL") if $running;
 545
 546         # to be sure
 547         kill(9, $pid);
 548         waitpid($pid, 0);
 549     }
 550
 551     if (-f $self->{pidfile}) {
 552         eval {
 553             # try to get the lock
 554             &$lockpidfile($self);
 555             &$server_cleanup($self);
 556         };
 557         if (my $err = $@) {
 558             &$log_err("cleanup failed - $err");
 559         }
 560     }
 561 }
 562
 563 sub register_start_command {
 564     my ($self, $description) = @_;
 565
 566     my $class = ref($self);
 567
 568     $class->register_method({
 569         name => 'start',
 570         path => 'start',
 571         method => 'POST',
 572         description => $description || "Start the daemon.",
 573         parameters => {
 574             additionalProperties => 0,
 575             properties => {
 576                 debug => {
 577                     description => "Debug mode - stay in foreground",
 578                     type => "boolean",
 579                     optional => 1,
 580                     default => 0,
 581                 },
 582             },
 583         },
 584         returns => { type => 'null' },
 585
 586         code => sub {
 587             my ($param) = @_;
 588
 589             $self->start($param->{debug});
 590
 591             return undef;
 592         }});
 593 }
 594
 595 my $reload_daemon = sub {
 596     my ($self, $use_hup) = @_;
 597
 598     if ($self->{env_restart_pve_daemon}) {
 599         $self->start();
 600     } else {
 601         my ($running, $pid) = $self->running();
 602         if (!$running) {
 603             $self->start();
 604         } else {
 605             if ($use_hup) {
 606                 syslog('info', "send HUP to $pid");
 607                 kill 1, $pid;
 608             } else {
 609                 $self->stop();
 610                 $self->start();
 611             }
 612         }
 613     }
 614 };
 615
 616 sub register_restart_command {
 617     my ($self, $use_hup, $description) = @_;
 618
 619     my $class = ref($self);
 620
 621     $class->register_method({
 622         name => 'restart',
 623         path => 'restart',
 624         method => 'POST',
 625         description => $description || "Restart the daemon (or start if not running).",
 626         parameters => {
 627             additionalProperties => 0,
 628             properties => {},
 629         },
 630         returns => { type => 'null' },
 631
 632         code => sub {
 633             my ($param) = @_;
 634
 635             &$reload_daemon($self, $use_hup);
 636
 637             return undef;
 638         }});
 639 }
 640
 641 sub register_reload_command {
 642     my ($self, $description) = @_;
 643
 644     my $class = ref($self);
 645
 646     $class->register_method({
 647         name => 'reload',
 648         path => 'reload',
 649         method => 'POST',
 650         description => $description || "Reload daemon configuration (or start if not running).",
 651         parameters => {
 652             additionalProperties => 0,
 653             properties => {},
 654         },
 655         returns => { type => 'null' },
 656
 657         code => sub {
 658             my ($param) = @_;
 659
 660             &$reload_daemon($self, 1);
 661
 662             return undef;
 663         }});
 664 }
 665
 666 sub register_stop_command {
 667     my ($self, $description) = @_;
 668
 669     my $class = ref($self);
 670
 671     $class->register_method({
 672         name => 'stop',
 673         path => 'stop',
 674         method => 'POST',
 675         description => $description || "Stop the daemon.",
 676         parameters => {
 677             additionalProperties => 0,
 678             properties => {},
 679         },
 680         returns => { type => 'null' },
 681
 682         code => sub {
 683             my ($param) = @_;
 684
 685             $self->stop();
 686
 687             return undef;
 688         }});
 689 }
 690
 691 sub register_status_command {
 692     my ($self, $description) = @_;
 693
 694     my $class = ref($self);
 695
 696     $class->register_method({
 697         name => 'status',
 698         path => 'status',
 699         method => 'GET',
 700         description => "Get daemon status.",
 701         parameters => {
 702             additionalProperties => 0,
 703             properties => {},
 704         },
 705         returns => {
 706             type => 'string',
 707             enum => ['stopped', 'running'],
 708         },
 709         code => sub {
 710             my ($param) = @_;
 711
 712             return $self->running() ? 'running' : 'stopped';
 713         }});
 714 }
 715
 716 1;
 717