1243fc7512bddabeed908a6f5a24945c72376471
[pve-common.git] / src / 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 # * keep lock open during restart
9 # * correctly daemonize (redirect STDIN/STDOUT)
10 # * restart by stop/start, exec, or signal HUP
11 # * daemon restart on error (option 'restart_on_error')
12 # * handle worker processes (option 'max_workers')
13 # * allow to restart while workers are still runningl
14 #   (option 'leave_children_open_on_reload')
15 # * run as different user using setuid/setgid
16  
17 use strict;
18 use warnings;
19 use English;
20
21 use PVE::SafeSyslog;
22 use PVE::INotify;
23
24 use POSIX ":sys_wait_h";
25 use Fcntl ':flock';
26 use Socket qw(IPPROTO_TCP TCP_NODELAY SOMAXCONN);
27 use IO::Socket::IP;
28
29 use Getopt::Long;
30 use Time::HiRes qw (gettimeofday);
31
32 use base qw(PVE::CLIHandler);
33
34 $ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
35
36 my $daemon_initialized = 0; # we only allow one instance
37
38 my $close_daemon_lock = sub {
39     my ($self) = @_;
40
41     return if !$self->{daemon_lock_fh};
42
43     close $self->{daemon_lock_fh};
44     delete $self->{daemon_lock_fh};
45 };
46
47 my $log_err = sub {
48     my ($msg) = @_;
49     chomp $msg;
50     print STDERR "$msg\n";
51     syslog('err', "%s", $msg);
52 };
53
54 # call this if you fork() from child
55 # Note: we already call this for workers, so it is only required
56 # if you fork inside a simple daemon (max_workers == 0).
57 sub after_fork_cleanup {
58     my ($self) = @_;
59
60     &$close_daemon_lock($self);
61
62     PVE::INotify::inotify_close();
63
64     for my $sig (qw(CHLD HUP INT TERM QUIT)) {
65         $SIG{$sig} = 'DEFAULT'; # restore default handler
66         # AnyEvent signals only works if $SIG{XX} is 
67         # undefined (perl event loop)
68         delete $SIG{$sig}; # so that we can handle events with AnyEvent
69     }
70 }
71
72 my $lockpidfile = sub {
73     my ($self) = @_;
74
75     my $lkfn = $self->{pidfile} . ".lock";
76
77     my $waittime = 0;
78
79     if (my $fd = $self->{env_pve_lock_fd}) {
80
81         $self->{daemon_lock_fh} = IO::Handle->new_from_fd($fd, "a");
82         
83     } else {
84
85         $waittime = 5;
86         $self->{daemon_lock_fh} = IO::File->new(">>$lkfn");
87     }
88
89     if (!$self->{daemon_lock_fh}) {
90         die "can't open lock '$lkfn' - $!\n";
91     }
92
93     for (my $i = 0; $i < $waittime; $i ++) {
94         return if flock ($self->{daemon_lock_fh}, LOCK_EX|LOCK_NB);
95         sleep(1);
96     }
97
98     if (!flock ($self->{daemon_lock_fh}, LOCK_EX|LOCK_NB)) {
99         &$close_daemon_lock($self);
100         my $err = $!;
101
102         my ($running, $pid) = $self->running();
103         if ($running) {
104             die "can't aquire lock '$lkfn' - daemon already started (pid = $pid)\n";
105         } else {
106             die "can't aquire lock '$lkfn' - $err\n";
107         }
108     }
109 };
110
111 my $writepidfile = sub {
112     my ($self) = @_;
113
114     my $pidfile = $self->{pidfile};
115
116     die "can't open pid file '$pidfile' - $!\n" if !open (PIDFH, ">$pidfile");
117
118     print PIDFH "$$\n";
119     close (PIDFH);
120 };
121
122 my $server_cleanup = sub {
123     my ($self) = @_;
124
125     unlink $self->{pidfile} . ".lock";
126     unlink $self->{pidfile};
127 };
128
129 my $finish_workers = sub {
130     my ($self) = @_;
131
132     foreach my $id (qw(workers old_workers)) {
133         foreach my $cpid (keys %{$self->{$id}}) {
134             my $waitpid = waitpid($cpid, WNOHANG);
135             if (defined($waitpid) && ($waitpid == $cpid)) {
136                 delete ($self->{$id}->{$cpid});
137                 syslog('info', "worker $cpid finished");
138             }
139         }
140     }
141 };
142
143 my $start_workers = sub {
144     my ($self) = @_;
145
146     return if $self->{terminate};
147
148     my $count = 0;
149     foreach my $cpid (keys %{$self->{workers}}) {
150         $count++;
151     }
152
153     my $need = $self->{max_workers} - $count;
154
155     return if $need <= 0;
156
157     syslog('info', "starting $need worker(s)");
158
159     while ($need > 0) {
160         my $pid = fork;
161
162         if (!defined ($pid)) {
163             syslog('err', "can't fork worker");
164             sleep (1);
165         } elsif ($pid) { # parent
166             $self->{workers}->{$pid} = 1;
167             syslog('info', "worker $pid started");
168             $need--;
169         } else {
170             $0 = "$self->{name} worker";
171
172             $self->after_fork_cleanup();
173
174             eval { $self->run(); };
175             if (my $err = $@) {
176                 syslog('err', $err);
177                 sleep(5); # avoid fast restarts
178             }
179
180             syslog('info', "worker exit");
181             exit (0);
182         }
183     }
184 };
185
186 my $terminate_server = sub {
187     my ($self, $allow_open_children) = @_;
188
189     $self->{terminate} = 1; # set flag to avoid worker restart
190
191     if (!$self->{max_workers}) {
192         eval { $self->shutdown(); };
193         warn $@ if $@;
194         return;
195     }
196
197     eval { $self->shutdown(); };
198     warn $@ if $@;
199
200     # we have workers - send TERM signal
201
202     foreach my $cpid (keys %{$self->{workers}}) {
203         kill(15, $cpid); # TERM childs
204     }
205
206     # if configured, leave children running on HUP
207     return if $allow_open_children &&
208         $self->{leave_children_open_on_reload};
209
210     # else, send TERM to old workers
211     foreach my $cpid (keys %{$self->{old_workers}}) {
212         kill(15, $cpid); # TERM childs
213     }
214
215     # nicely shutdown childs (give them max 10 seconds to shut down)
216     my $previous_alarm = alarm(10);
217     eval {
218         local $SIG{ALRM} = sub { die "timeout\n" };
219
220         while ((my $pid = waitpid (-1, 0)) > 0) {
221             foreach my $id (qw(workers old_workers)) {
222                 if (defined($self->{$id}->{$pid})) {
223                     delete($self->{$id}->{$pid});
224                     syslog('info', "worker $pid finished");
225                 }
226             }
227         }
228         alarm(0); # avoid race condition
229     };
230     my $err = $@;
231
232     alarm ($previous_alarm);
233
234     if ($err) {
235         syslog('err', "error stopping workers (will kill them now) - $err");
236         foreach my $id (qw(workers old_workers)) {
237             foreach my $cpid (keys %{$self->{$id}}) {
238                 # KILL childs still alive!
239                 if (kill (0, $cpid)) {
240                     delete($self->{$id}->{$cpid});
241                     syslog("err", "kill worker $cpid");
242                     kill(9, $cpid);
243                     # fixme: waitpid?
244                 }
245             }
246         }
247     }
248 };
249
250 sub setup {
251     my ($self) = @_;
252
253     initlog($self->{name});
254
255     my $restart = $ENV{RESTART_PVE_DAEMON};
256     delete $ENV{RESTART_PVE_DAEMON};
257     $self->{env_restart_pve_daemon} = $restart;
258
259     my $lockfd = $ENV{PVE_DAEMON_LOCK_FD};
260     delete $ENV{PVE_DAEMON_LOCK_FD};
261     if (defined($lockfd)) {
262         die "unable to parse lock fd '$lockfd'\n"
263             if $lockfd !~ m/^(\d+)$/;
264         $lockfd = $1; # untaint
265     }
266     $self->{env_pve_lock_fd} = $lockfd;
267
268     die "please run as root\n" if !$restart && ($> != 0);
269
270     die "can't create more that one PVE::Daemon" if $daemon_initialized;
271     $daemon_initialized = 1;
272
273     PVE::INotify::inotify_init();
274
275     if (my $gidstr = $self->{setgid}) {
276         my $gid = getgrnam($gidstr) || die "getgrnam failed - $!\n";
277         POSIX::setgid($gid) || die "setgid $gid failed - $!\n";
278         $EGID = "$gid $gid"; # this calls setgroups
279         # just to be sure
280         die "detected strange gid\n" if !($GID eq "$gid $gid" && $EGID eq "$gid $gid");
281     }
282
283     if (my $uidstr = $self->{setuid}) {
284         my $uid = getpwnam($uidstr) || die "getpwnam failed - $!\n";
285         POSIX::setuid($uid) || die "setuid $uid failed - $!\n";
286         # just to be sure
287         die "detected strange uid\n" if !($UID == $uid && $EUID == $uid);
288     }
289
290     if ($restart && $self->{max_workers}) {
291         if (my $wpids = $ENV{PVE_DAEMON_WORKER_PIDS}) {
292             foreach my $pid (split(':', $wpids)) {
293                 if ($pid =~ m/^(\d+)$/) {
294                     $self->{old_workers}->{$1} = 1;
295                 }
296             }
297         }
298     }
299
300     $self->{nodename} = PVE::INotify::nodename();
301 }
302
303 my $server_run = sub {
304     my ($self, $debug) = @_;
305
306     # fixme: handle restart lockfd
307     &$lockpidfile($self);
308
309     # remove FD_CLOEXEC bit to reuse on exec
310     $self->{daemon_lock_fh}->fcntl(Fcntl::F_SETFD(), 0);
311
312     $ENV{PVE_DAEMON_LOCK_FD} = $self->{daemon_lock_fh}->fileno;
313
314     # run in background
315     my $spid;
316
317     $self->{debug} = 1 if $debug;
318
319     $self->init();
320
321     if (!$debug) {
322         open STDIN,  '</dev/null' || die "can't read /dev/null";
323         open STDOUT, '>/dev/null' || die "can't write /dev/null";
324     }
325
326     if (!$self->{env_restart_pve_daemon} && !$debug) {
327         PVE::INotify::inotify_close();
328         $spid = fork();
329         if (!defined ($spid)) {
330             die "can't put server into background - fork failed";
331         } elsif ($spid) { # parent
332             exit (0);
333         }
334         PVE::INotify::inotify_init();
335     }
336
337     if ($self->{env_restart_pve_daemon}) {
338         syslog('info' , "restarting server");
339     } else {
340         &$writepidfile($self);
341         syslog('info' , "starting server");
342     }
343
344     POSIX::setsid(); 
345
346     open STDERR, '>&STDOUT' || die "can't close STDERR\n";
347
348     my $old_sig_term = $SIG{TERM};
349     local $SIG{TERM} = sub {
350         local ($@, $!, $?); # do not overwrite error vars
351         syslog('info', "received signal TERM");
352         &$terminate_server($self, 0);
353         &$server_cleanup($self);
354         &$old_sig_term(@_) if $old_sig_term;
355     };
356
357     my $old_sig_quit = $SIG{QUIT};
358     local $SIG{QUIT} = sub {
359         local ($@, $!, $?); # do not overwrite error vars
360         syslog('info', "received signal QUIT");
361         &$terminate_server($self, 0);
362         &$server_cleanup($self);
363         &$old_sig_quit(@_) if $old_sig_quit;
364     };
365
366     my $old_sig_int = $SIG{INT};
367     local $SIG{INT} = sub {
368         local ($@, $!, $?); # do not overwrite error vars
369         syslog('info', "received signal INT");
370         $SIG{INT} = 'DEFAULT'; # allow to terminate now
371         &$terminate_server($self, 0);
372         &$server_cleanup($self);
373         &$old_sig_int(@_) if $old_sig_int;
374     };
375
376     $SIG{HUP} = sub {
377         local ($@, $!, $?); # do not overwrite error vars
378         syslog('info', "received signal HUP");
379         $self->{got_hup_signal} = 1;
380         if ($self->{max_workers}) {
381             &$terminate_server($self, 1);
382         } elsif ($self->can('hup')) {
383             eval { $self->hup() };
384             warn $@ if $@;
385         }
386     };
387
388     eval { 
389         if ($self->{max_workers}) {
390             my $old_sig_chld = $SIG{CHLD};
391             local $SIG{CHLD} = sub {
392                 local ($@, $!, $?); # do not overwrite error vars
393                 &$finish_workers($self);
394                 &$old_sig_chld(@_) if $old_sig_chld;
395             };
396
397             # catch worker finished during restart phase 
398             &$finish_workers($self);
399
400             # now loop forever (until we receive terminate signal)
401             for (;;) { 
402                 &$start_workers($self);
403                 sleep(5);
404                 &$finish_workers($self);
405                 last if $self->{terminate};
406             }
407
408         } else {
409             $self->run();
410         } 
411     };
412     my $err = $@;
413
414     if ($err) {
415         syslog ('err', "ERROR: $err");
416
417         &$terminate_server($self, 1);
418
419         if (my $wait_time = $self->{restart_on_error}) {
420             $self->restart_daemon($wait_time);
421         } else {
422             $self->exit_daemon(-1);
423         }
424     }
425
426     if ($self->{got_hup_signal}) {
427         $self->restart_daemon();
428     } else {
429         $self->exit_daemon(0);
430     }
431 };
432
433 sub new {
434     my ($this, $name, $cmdline, %params) = @_;
435
436     $name = 'daemon' if !$name; # should not happen
437
438     my $self;
439
440     eval {
441         my $class = ref($this) || $this;
442
443         $self = bless { 
444             name => $name,
445             pidfile => "/var/run/${name}.pid",
446             workers => {},
447             old_workers => {},
448         }, $class;
449
450
451         foreach my $opt (keys %params) {
452             my $value = $params{$opt};
453             if ($opt eq 'restart_on_error') {
454                 $self->{$opt} = $value;
455             } elsif ($opt eq 'stop_wait_time') {
456                 $self->{$opt} = $value;
457             } elsif ($opt eq 'pidfile') {
458                 $self->{$opt} = $value;
459             } elsif ($opt eq 'max_workers') {
460                 $self->{$opt} = $value;
461             } elsif ($opt eq 'leave_children_open_on_reload') {
462                 $self->{$opt} = $value;
463             } elsif ($opt eq 'setgid') {
464                 $self->{$opt} = $value;
465             } elsif ($opt eq 'setuid') {
466                 $self->{$opt} = $value;
467             } else {
468                 die "unknown daemon option '$opt'\n";
469             }
470         }
471         
472
473         # untaint
474         $self->{cmdline} = [map { /^(.*)$/ } @$cmdline];
475
476         $0 = $name;
477     };
478     if (my $err = $@) {
479         &$log_err($err);
480         exit(-1);
481     }
482
483     return $self;
484 }
485
486 sub exit_daemon {
487     my ($self, $status) = @_;
488
489     syslog("info", "server stopped");
490
491     &$server_cleanup($self);
492
493     exit($status);
494 }
495
496 sub restart_daemon {
497     my ($self, $waittime) = @_;
498
499     syslog('info', "server shutdown (restart)");
500
501     $ENV{RESTART_PVE_DAEMON} = 1;
502
503     if ($self->{max_workers}) {
504         my @workers = keys %{$self->{workers}};
505         push @workers, keys %{$self->{old_workers}};
506         $ENV{PVE_DAEMON_WORKER_PIDS} = join(':', @workers);
507     }
508
509     sleep($waittime) if $waittime; # avoid high server load due to restarts
510
511     PVE::INotify::inotify_close();
512
513     exec (@{$self->{cmdline}});
514
515     exit (-1); # never reached?
516 }
517
518 # please overwrite in subclass
519 # this is called at startup - before forking
520 sub init {
521     my ($self) = @_;
522
523 }
524
525 # please overwrite in subclass
526 sub shutdown {
527     my ($self) = @_;
528
529     syslog('info' , "server closing");
530
531     if (!$self->{max_workers}) {
532         # wait for children
533         1 while (waitpid(-1, POSIX::WNOHANG()) > 0);
534     }
535 }
536
537 # please define in subclass
538 #sub hup {
539 #    my ($self) = @_;
540 #
541 #    syslog('info' , "received signal HUP (restart)");
542 #}
543
544 # please overwrite in subclass
545 sub run {
546     my ($self) = @_;
547
548     for (;;) { # forever
549         syslog('info' , "server is running");
550         sleep(5);
551     }
552 }
553
554 sub start {
555     my ($self, $debug) = @_;
556
557     eval  {
558         $self->setup();
559         &$server_run($self, $debug);
560     };
561     if (my $err = $@) {
562         &$log_err("start failed - $err");
563         exit(-1);
564     }
565 }
566
567 my $read_pid = sub {
568     my ($self) = @_;
569
570     my $pid_str = PVE::Tools::file_read_firstline($self->{pidfile});
571
572     return 0 if !$pid_str;
573
574     return 0 if $pid_str !~ m/^(\d+)$/; # untaint
575  
576     my $pid = int($1);
577
578     return $pid;
579 };
580
581 # checks if the process was started by systemd
582 my $init_ppid = sub {
583
584     if (getppid() == 1) {
585        return 1;
586     } else {
587        return 0;
588     }
589 }; 
590
591 sub running {
592     my ($self) = @_;
593
594     my $pid = &$read_pid($self);
595
596     if ($pid) {
597         my $res = PVE::ProcFSTools::check_process_running($pid) ? 1 : 0;
598         return wantarray ? ($res, $pid) : $res;
599     }
600
601     return wantarray ? (0, 0) : 0;
602 }
603
604 sub stop {
605     my ($self) = @_;
606
607     my $pid = &$read_pid($self);
608
609     return if !$pid;
610
611     if (PVE::ProcFSTools::check_process_running($pid)) {
612         kill(15, $pid); # send TERM signal
613         # give some time
614         my $wait_time = $self->{stop_wait_time} || 5;
615         my $running = 1;
616         for (my $i = 0; $i < $wait_time; $i++) {
617             $running = PVE::ProcFSTools::check_process_running($pid);
618             last if !$running;
619             sleep (1);
620         }
621
622         syslog('err', "server still running - send KILL") if $running;
623
624         # to be sure
625         kill(9, $pid);
626         waitpid($pid, 0);
627     }
628
629     if (-f $self->{pidfile}) {
630         eval {
631             # try to get the lock
632             &$lockpidfile($self);
633             &$server_cleanup($self);
634         };
635         if (my $err = $@) {
636             &$log_err("cleanup failed - $err");
637         }
638     }
639 }
640
641 sub register_start_command {
642     my ($self, $description) = @_;
643
644     my $class = ref($self);
645
646     $class->register_method({
647         name => 'start',
648         path => 'start',
649         method => 'POST',
650         description => $description || "Start the daemon.",
651         parameters => {
652             additionalProperties => 0,
653             properties => {
654                 debug => {
655                     description => "Debug mode - stay in foreground",
656                     type => "boolean",
657                     optional => 1,
658                     default => 0,
659                 },
660             },
661         },
662         returns => { type => 'null' },
663
664         code => sub {
665             my ($param) = @_;
666
667             if (&$init_ppid()) {
668                 $self->start($param->{debug});
669             } else {
670                 PVE::Tools::run_command(['systemctl', 'start', $self->{name}]);
671             }
672
673             return undef;
674         }});  
675 }
676
677 my $reload_daemon = sub {
678     my ($self, $use_hup) = @_;
679
680     if ($self->{env_restart_pve_daemon}) {
681         $self->start();
682     } else {
683         my ($running, $pid) = $self->running(); 
684         if (!$running) {
685             $self->start();
686         } else {
687             if ($use_hup) {
688                 syslog('info', "send HUP to $pid");
689                 kill 1, $pid;
690             } else {
691                 $self->stop();
692                 $self->start();
693             }
694         }
695     }
696 };
697
698 sub register_restart_command {
699     my ($self, $use_hup, $description) = @_;
700
701     my $class = ref($self);
702
703     $class->register_method({
704         name => 'restart',
705         path => 'restart',
706         method => 'POST',
707         description => $description || "Restart the daemon (or start if not running).",
708         parameters => {
709             additionalProperties => 0,
710             properties => {},
711         },
712         returns => { type => 'null' },
713
714         code => sub {
715             my ($param) = @_;
716
717             if (&$init_ppid()) {
718                 &$reload_daemon($self, $use_hup);
719             } else {
720                 PVE::Tools::run_command(['systemctl', $use_hup ? 'reload-or-restart' : 'restart', $self->{name}]);
721             }
722
723             return undef;
724         }});               
725 }
726
727 sub register_reload_command {
728     my ($self, $description) = @_;
729
730     my $class = ref($self);
731
732     $class->register_method({
733         name => 'reload',
734         path => 'reload',
735         method => 'POST',
736         description => $description || "Reload daemon configuration (or start if not running).",
737         parameters => {
738             additionalProperties => 0,
739             properties => {},
740         },
741         returns => { type => 'null' },
742
743         code => sub {
744             my ($param) = @_;
745
746             &$reload_daemon($self, 1);
747
748             return undef;
749         }});               
750 }
751
752 sub register_stop_command {
753     my ($self, $description) = @_;
754
755     my $class = ref($self);
756
757     $class->register_method({
758         name => 'stop',
759         path => 'stop',
760         method => 'POST',
761         description => $description || "Stop the daemon.",
762         parameters => {
763             additionalProperties => 0,
764             properties => {},
765         },
766         returns => { type => 'null' },
767
768         code => sub {
769             my ($param) = @_;
770             
771             if (&$init_ppid()) {
772                 $self->stop();
773             } else {
774                 PVE::Tools::run_command(['systemctl', 'stop', $self->{name}]);
775             }
776
777             return undef;
778         }});               
779 }
780
781 sub register_status_command {
782     my ($self, $description) = @_;
783
784     my $class = ref($self);
785
786     $class->register_method({
787         name => 'status',
788         path => 'status',
789         method => 'GET',
790         description => "Get daemon status.",
791         parameters => {
792             additionalProperties => 0,
793             properties => {},
794         },
795         returns => { 
796             type => 'string',
797             enum => ['stopped', 'running'],
798         },
799         code => sub {
800             my ($param) = @_;
801
802             return $self->running() ? 'running' : 'stopped';
803         }});
804 }
805
806 # some useful helper
807
808 sub create_reusable_socket {
809     my ($self, $port, $host, $family) = @_;
810
811     die "no port specifed" if !$port;
812
813     my ($socket, $sockfd);
814
815     if (defined($sockfd = $ENV{"PVE_DAEMON_SOCKET_$port"}) &&
816         $self->{env_restart_pve_daemon}) {
817
818         die "unable to parse socket fd '$sockfd'\n" 
819             if $sockfd !~ m/^(\d+)$/;
820         $sockfd = $1; # untaint
821
822         $socket = IO::Socket::IP->new;
823         $socket->fdopen($sockfd, 'w') || 
824             die "cannot fdopen file descriptor '$sockfd' - $!\n";
825
826     } else {
827
828         $socket = IO::Socket::IP->new(
829             LocalAddr => $host,
830             LocalPort => $port,
831             Listen => SOMAXCONN,
832             Family => $family,
833             Proto  => 'tcp',
834             GetAddrInfoFlags => 0,
835             ReuseAddr => 1) ||
836             die "unable to create socket - $@\n";
837
838         # we often observe delays when using Nagle algorithm,
839         # so we disable that to maximize performance
840         setsockopt($socket, IPPROTO_TCP, TCP_NODELAY, 1);
841
842         $ENV{"PVE_DAEMON_SOCKET_$port"} = $socket->fileno;
843     }
844
845     # remove FD_CLOEXEC bit to reuse on exec
846     $socket->fcntl(Fcntl::F_SETFD(), 0);
847     
848     return $socket;
849 }
850
851
852 1;
853