LP#1204123 osrf_control warn and exit on bad host
[OpenSRF.git] / bin / opensrf-perl.pl.in
1 #!/usr/bin/perl
2 # ---------------------------------------------------------------
3 # Copyright (C) 2008-2013 Georgia Public Library Service
4 # Copyright (C) 2013 Equinox Software, Inc
5 # Bill Erickson <berick@esilibrary.com>
6 #
7 # This program is free software; you can redistribute it and/or
8 # modify it under the terms of the GNU General Public License
9 # as published by the Free Software Foundation; either version 2
10 # of the License, or (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 # GNU General Public License for more details.
16 # ---------------------------------------------------------------
17 use strict; use warnings;
18 use Getopt::Long;
19 use Net::Domain qw/hostfqdn/;
20 use POSIX qw/setsid :sys_wait_h/;
21 use OpenSRF::Utils::Logger q/$logger/;
22 use OpenSRF::System;
23 use OpenSRF::Transport::PeerHandle;
24 use OpenSRF::Utils::SettingsClient;
25 use OpenSRF::Transport::Listener;
26 use OpenSRF::Utils;
27 use OpenSRF::Utils::Config;
28
29 my $opt_service = undef;
30 my $opt_config = "@CONF_DIR@/opensrf_core.xml";
31 my $opt_pid_dir = "@PID_DIR@/run/opensrf";
32 my $opt_no_daemon = 0;
33 my $opt_settings_pause = 0;
34 my $opt_localhost = 0;
35 my $opt_help = 0;
36 my $opt_shutdown_graceful = 0;
37 my $opt_shutdown_fast = 0;
38 my $opt_shutdown_immediate = 0;
39 my $opt_shutdown_graceful_all = 0;
40 my $opt_shutdown_fast_all = 0;
41 my $opt_shutdown_immediate_all = 0;
42 my $opt_kill_with_fire = 0;
43 my $opt_signal = ''; # signal name
44 my $opt_signal_all = 0;
45 my $opt_signal_timeout = 30;
46 my $opt_start = 0;
47 my $opt_stop = 0;
48 my $opt_restart = 0;
49 my $opt_start_all = 0;
50 my $opt_stop_all = 0;
51 my $opt_restart_all = 0;
52 my $opt_force_clean_process = 0;
53 my $opt_quiet = 0;
54 my $opt_diagnostic = 0;
55 my $sclient;
56 my @perl_services;
57 my @nonperl_services;
58 my $hostname = $ENV{OSRF_HOSTNAME} || hostfqdn();
59
60 GetOptions(
61     'service=s' => \$opt_service,
62     'config=s' => \$opt_config,
63     'pid-dir=s' => \$opt_pid_dir,
64     'no-daemon' => \$opt_no_daemon,
65     'settings-startup-pause=i' => \$opt_settings_pause,
66     'localhost' => \$opt_localhost,
67     'help' => \$opt_help,
68     'quiet' => \$opt_quiet,
69     'graceful-shutdown' => \$opt_shutdown_graceful,
70     'fast-shutdown' => \$opt_shutdown_fast,
71     'immediate-shutdown' => \$opt_shutdown_immediate,
72     'graceful-shutdown-all' => \$opt_shutdown_graceful_all,
73     'fast-shutdown-all' => \$opt_shutdown_fast_all,
74     'immediate-shutdown-all' => \$opt_shutdown_immediate_all,
75     'kill-with-fire' => \$opt_kill_with_fire,
76     'force-clean-process' => \$opt_force_clean_process,
77     'signal-timeout' => \$opt_signal_timeout,
78     'signal=s' => \$opt_signal,
79     'signal-all' => \$opt_signal_all,
80     'start' => \$opt_start,
81     'stop' => \$opt_stop,
82     'start-all' => \$opt_start_all,
83     'stop-all' => \$opt_stop_all,
84     'restart' => \$opt_restart,
85     'restart-all' => \$opt_restart_all,
86     'diagnostic' => \$opt_diagnostic
87 );
88
89 if ($opt_localhost) {
90     $hostname = 'localhost';
91     $ENV{OSRF_HOSTNAME} = $hostname;
92 }
93
94 my $C_COMMAND = "opensrf-c -c $opt_config -x opensrf -p $opt_pid_dir -h $hostname";
95 my $PY_COMMAND = "opensrf.py -f $opt_config -p $opt_pid_dir ". ($opt_localhost ? '-l' : '');
96
97 sub verify_services {
98     my $service = shift;
99     my @services = (@perl_services, map {$_->{service}} @nonperl_services);
100     if (@services) {
101         return 1 unless $service;
102         return 1 if grep { $_ eq $service } @services;
103         msg("$service is not configured to run on $hostname");
104     } else {
105         msg("No services are configured to run on $hostname");
106     }
107     msg("Perhaps you meant to use --localhost?") unless $opt_localhost;
108     exit;
109 }
110
111 sub do_signal_send {
112     my $service = shift;
113     my $signal = shift;
114
115     my @pids = get_service_pids_from_file($service);
116
117     if (!@pids) {
118         # no PID files exist.  see if the service is running anyway
119
120         @pids = get_service_pids_from_ps($service);
121         if (!@pids) {
122             msg("cannot signal $service : no pid file or running process");
123             return 0;
124         }
125     }
126
127     for my $pid (@pids) {
128         if (kill($signal, $pid) == 0) { # no process was signaled.  
129             msg("cannot signal $service: process $pid is not running");
130             my $pidfile = get_pid_file($service);
131             unlink $pidfile if $pidfile;
132             next;
133         }
134
135         msg("sending $signal signal to pid=$pid $service");
136     }
137
138     return 1;
139 }
140
141 # returns 2 if a process should have gone away but did not
142 # in the case of multiple PIDs (e.g. router), return the 
143 # status of any failures, but not the successes.
144 sub do_signal_wait {
145     my $service = shift;
146     my @pids = get_service_pids_from_file($service);
147
148     my $stat = 1;
149     for my $pid (@pids) {
150
151         # to determine whether a process has died, we have to send
152         # a no-op signal to the PID and check the success of that signal
153         my $sig_count;
154         for my $i (1..$opt_signal_timeout) {
155             $sig_count = kill(0, $pid);
156             last unless $sig_count;
157             sleep(1);
158         }
159
160         if ($sig_count) {
161             msg("timed out waiting on $service pid=$pid to die");
162             $stat = 2;
163             next;
164         }
165
166         # cleanup successful. remove the PID file
167         my $pidfile = get_pid_file($service);
168         unlink $pidfile if $pidfile;
169     }
170
171     return $stat;
172 }
173
174 sub get_pid_file {
175     my $service = shift;
176     return "$opt_pid_dir/$service.pid";
177 }
178
179 # services usually only have 1 pid, but the router will have at least 2
180 sub get_service_pids_from_file {
181     my $service = shift;
182     my $pid_file = get_pid_file($service);
183     return () unless -e $pid_file;
184     my @pids = `cat $pid_file`;
185     s/^\s*|\n//g for @pids;
186     return @pids;
187 }
188
189 sub get_service_pids_from_ps {
190     my $service = shift;
191
192     my $ps = ($service eq 'router') ?
193         "ps ax | grep 'OpenSRF Router'" :
194         "ps ax | grep 'OpenSRF Listener \\[$service\\]'";
195
196     $ps .= " | grep -v grep |  sed 's/^\\s*//' | cut -d' ' -f1";
197     my @pids = `$ps`;
198     s/^\s*|\n//g for @pids;
199
200     return @pids;
201 }
202
203
204 sub do_diagnostic {
205     my $alive = do_init(1);
206
207     my @services = get_service_list_from_files(1);
208     my @conf_services;
209     if ($alive) {
210         @conf_services = (@perl_services, 
211             map {$_->{service}} @nonperl_services);
212         push(@services, @conf_services);
213     }
214     
215     my %services;
216     my $len = 0;
217     for my $svc (@services) {
218         $len = length($svc) if length($svc) > $len;
219         $services{$svc} = 1;
220     }
221
222     for my $svc (sort keys %services) {
223         my @pf_pids = get_service_pids_from_file($svc);
224         my @ps_pids = get_service_pids_from_ps($svc); 
225         my $svc_str = sprintf("%-${len}s ", $svc);
226         my %seen;
227
228         unless(@ps_pids or @pf_pids) {
229             msg("$svc_str is not running");
230             next;
231         }
232
233         for my $pid (@ps_pids) {
234             $seen{$pid} = 1;
235
236             my $str = "$svc_str [$pid] ";
237             my $times = `ps -o etime=,cputime= $pid`;
238             $times =~ s/^\s+|\s+$//g;
239             my @times = split(/ /, $times);
240             $str .= sprintf("uptime=%-11s cputime=%-11s ", $times[0], $times[1]);
241
242             if ($svc eq 'router') {
243                 msg($str);
244             } else {
245                 my @drones = `pgrep -f "Drone \\[$svc\\]"`;
246                 $str .= "#drones=".scalar(@drones);
247                 msg($str);
248                 msg("\tERR $svc has no running drones.") unless @drones;
249             }
250
251             msg("\tERR $svc [$pid] NOT configured for this host.")
252                 unless grep {$_ eq $svc} @conf_services 
253                 or $svc eq 'router';
254
255             msg("\tERR $svc [$pid] NOT found in PID file.")
256                 unless grep {$_ eq $pid} @pf_pids;
257         }
258
259         for my $pid (@pf_pids) {
260             next if $seen{$pid};
261             msg("\tERR $svc Has PID file entry [$pid], ".
262                 "which matches no running $svc processes");
263         }
264     }
265 }
266
267
268
269 sub do_start_router {
270     `opensrf_router $opt_config routers`;
271
272     sleep 2; # give the router time to fork
273     my @pids = `ps -C opensrf_router -o pid=`;
274     s/^\s*|\n//g for @pids;
275
276     my $pidfile = get_pid_file('router');
277     open(PF, '>', $pidfile) or die "Cannot open $pidfile: $!\n";
278     foreach (@pids) {
279         chomp;
280         msg("starting service pid=$_ router");
281         print PF "$_\n";
282     }
283     close PF;
284 }
285
286 # stop a specific service
287 sub do_stop {
288     my ($service, @signals) = @_;
289     @signals = qw/TERM INT KILL/ unless @signals;
290     for my $sig (@signals) {
291         last unless do_signal($service, $sig) == 2;
292     }
293     return 1;
294 }
295
296 sub do_init {
297     my $fail_ok = shift;
298
299     OpenSRF::System->bootstrap_client(config_file => $opt_config);
300
301     if (!OpenSRF::Transport::PeerHandle->retrieve) {
302         return 0 if $fail_ok;
303         die "Unable to bootstrap client for requests\n";
304     }
305
306     load_settings(); # load the settings config if we can
307
308     my $sclient = OpenSRF::Utils::SettingsClient->new;
309     my $apps = $sclient->config_value("activeapps", "appname");
310
311     # disconnect the top-level network handle
312     OpenSRF::Transport::PeerHandle->retrieve->disconnect;
313
314     if($apps) {
315         $apps = [$apps] unless ref $apps;
316         for my $app (@$apps) {
317             if (!$sclient->config_value('apps', $app)) {
318                 msg("Service '$app' is listed for this host, ".
319                     "but there is no configuration for it in $opt_config");
320                 next;
321             }
322             my $lang = $sclient->config_value('apps', $app, 'language') || '';
323             if ($lang =~ /perl/i) {
324                 push(@perl_services, $app);
325             } else {
326                 push(@nonperl_services, {service => $app, lang => $lang});
327             }
328         }
329     }
330     return 1;
331 }
332
333 # start a specific service
334 sub do_start {
335     my $service = shift;
336
337     my @pf_pids = get_service_pids_from_file($service);
338     my @ps_pids = get_service_pids_from_ps($service); 
339
340     if (@pf_pids) { # had pidfile
341
342         if (@ps_pids) {
343             msg("service $service already running : @ps_pids");
344             return;
345
346         } else { # stale pidfile
347
348             my $pidfile = get_pid_file($service);
349             msg("removing stale pid file $pidfile");
350             unlink $pidfile;
351         }
352
353     } elsif (@ps_pids) { # orphan process
354
355         if ($opt_force_clean_process) {
356             msg("service $service pid=@ps_pids is running with no pidfile");
357             do_signal($service, 'KILL');
358         } else {
359             msg("service $service pid=@ps_pids is running with no pidfile! ".
360                 "use --force-clean-process to automatically kill orphan processes");
361             return;
362         }
363     }
364
365     return do_start_router() if $service eq 'router';
366
367     load_settings() if $service eq 'opensrf.settings';
368
369     if(grep { $_ eq $service } @perl_services) {
370         return unless do_daemon($service);
371         OpenSRF::System->run_service($service, $opt_pid_dir);
372
373     } else {
374         # note: we don't daemonize non-perl services, but instead
375         # assume the controller for other languages manages that.
376         my ($svc) = grep { $_->{service} eq $service } @nonperl_services;
377         if ($svc) {
378             if ($svc->{lang} =~ /c/i) {
379                 system("$C_COMMAND -a start -s $service");
380                 return;
381             } elsif ($svc->{lang} =~ /python/i) {
382                 system("$PY_COMMAND -a start -s $service");
383                 return;
384             }
385         }
386     }
387
388     # should not get here
389     return 0;
390 }
391
392 sub do_start_all {
393     msg("starting all services for $hostname");
394     do_start('router');
395
396     if(grep {$_ eq 'opensrf.settings'} @perl_services) {
397         do_start('opensrf.settings');
398         # in batch mode, give opensrf.settings plenty of time to start 
399         # before any non-Perl services try to connect
400         sleep $opt_settings_pause if $opt_settings_pause;
401     }
402
403     # start Perl services
404     for my $service (@perl_services) {
405         do_start($service) unless $service eq 'opensrf.settings';
406     }
407
408     # start each non-perl service individually instead of using the native
409     # start-all command.  this allows us to test for existing pid files 
410     # and/or running processes on each service before starting.
411     # it also means each service has to connect-fetch_setting-disconnect
412     # from jabber, which makes startup slightly slower than native start-all
413     do_start($_->{service}) for @nonperl_services;
414
415     return 1;
416 }
417
418 # signal a single service
419 sub do_signal {
420     my $service = shift;
421     my $signal = shift;
422     return do_signal_all($signal, $service);
423 }
424
425 # returns the list of running services based on presence of PID files.
426 # the 'router' service is not included by deault, since it's 
427 # usually treated special.
428 sub get_service_list_from_files {
429     my $include_router = shift;
430     my @services = `ls $opt_pid_dir/*.pid 2> /dev/null`;
431     s/^\s*|\n//g for @services;
432     s|.*/(.*)\.pid$|$1| for @services;
433     return @services if $include_router;
434     return grep { $_ ne 'router' } @services;
435
436
437 sub do_signal_all {
438     my ($signal, @services) = @_;                                              
439     @services = get_service_list_from_files() unless @services;     
440
441     do_signal_send($_, $signal) for @services;
442
443     # if user passed a know non-shutdown signal, we're done.
444     return if $signal =~ /HUP|USR1|USR2/;
445
446     do_signal_wait($_) for @services;
447 }
448
449 # pull all opensrf listener and drone PIDs from 'ps', 
450 # kill them all, and remove all pid files
451 sub do_kill_with_fire {
452     msg("killing with fire");
453
454     my @pids = get_running_pids();
455     for (@pids) {
456         next unless $_ =~ /\d+/;
457         my $proc = `ps -p $_ -o cmd=`;
458         chomp $proc;
459         msg("killing with fire pid=$_ $proc");
460         kill('KILL', $_);
461     }
462
463     # remove all of the pid files
464     my @files = `ls $opt_pid_dir/*.pid 2> /dev/null`;
465     s/^\s*|\n//g for @files;
466     for (@files) {
467         msg("removing pid file $_");
468         unlink $_;
469     }
470 }
471
472 sub get_running_pids {
473     my @pids;
474
475     # start with the listeners, then drones, then routers
476     my @greps = (
477         "ps ax | grep 'OpenSRF Listener' ",
478         "ps ax | grep 'OpenSRF Drone' ",
479         "ps ax | grep 'OpenSRF Router' "
480     );
481
482     $_ .= "| grep -v grep |  sed 's/^\\s*//' | cut -d' ' -f1" for @greps;
483
484     for my $grep (@greps) {
485         my @spids = `$grep`;
486         s/^\s*|\n//g for @spids;
487         push (@pids, @spids);
488     }
489
490     return @pids;
491 }
492
493 sub clear_stale_pids {
494     my @pidfile_services = get_service_list_from_files(1);
495     my @running_pids = get_running_pids();
496     
497     for my $svc (@pidfile_services) {
498         my @pids = get_service_pids_from_file($svc);
499         for my $pid (@pids) {
500             next if grep { $_ eq $pid } @running_pids;
501             my $pidfile = get_pid_file($svc);
502             msg("removing stale pid file $pidfile");
503             unlink $pidfile;
504         }
505     }
506 }
507
508 sub do_stop_all {
509     my @signals = @_;
510
511     msg("stopping all services for $hostname");
512
513     my @services = get_service_list_from_files();
514     @signals = qw/TERM INT KILL/ unless @signals;
515     
516     for my $signal (@signals) {
517         my @redo;
518
519         # send the signal to all PIDs
520         do_signal_send($_, $signal) for @services;
521
522         # then wait for them to go away
523         for my $service (@services) {
524             push(@redo, $service) if do_signal_wait($service) == 2;
525         }
526
527         @services = @redo;
528         last unless @services;
529     }
530
531     # graceful shutdown requires the presence of the router, so stop the 
532     # router last.  See if it's running first to avoid unnecessary warnings.
533     do_stop('router', $signals[0]) if get_service_pids_from_file('router'); 
534
535     return 1;
536 }
537
538 # daemonize us.  return true if we're the child, false if parent
539 sub do_daemon {
540     return 1 if $opt_no_daemon;
541     my $service = shift;
542     my $pid_file = get_pid_file($service);
543     my $pid = OpenSRF::Utils::safe_fork();
544     if ($pid) { # parent
545         msg("starting service pid=$pid $service");
546         return 0;
547     }
548     chdir('/');
549     setsid();
550     close STDIN;
551     close STDOUT;
552     close STDERR;
553     open STDIN, '</dev/null';
554     open STDOUT, '>/dev/null';
555     open STDERR, '>/dev/null';
556     `echo $$ > $pid_file`;
557     return 1;
558 }
559
560 # parses the local settings file
561 sub load_settings {
562     my $conf = OpenSRF::Utils::Config->current;
563     my $cfile = $conf->bootstrap->settings_config;
564     return unless $cfile;
565     my $parser = OpenSRF::Utils::SettingsParser->new();
566     $parser->initialize( $cfile );
567     $OpenSRF::Utils::SettingsClient::host_config =
568         $parser->get_server_config($conf->env->hostname);
569 }
570
571 sub msg {
572     my $m = shift;
573     print "* $m\n" unless $opt_quiet;
574 }
575
576 sub do_help {
577     print <<HELP;
578
579     Usage: $0 --localhost --start-all
580
581     --config <file> [default: @CONF_DIR@/opensrf_core.xml]
582         OpenSRF configuration file 
583         
584     --pid-dir <dir> [default: @PID_DIR@/run/opensrf]
585         Directory where process-specific PID files are kept
586
587     --settings-startup-pause
588         How long to give the opensrf.settings server to start up when running 
589         in batch mode (start_all).  The purpose is to give plenty of time for
590         the settings server to be up and active before any non-Perl services
591         attempt to connect.
592
593     --localhost
594         Force the hostname to be 'localhost', instead of the fully qualified
595         domain name for the machine.
596
597     --service <service>
598         Specifies which OpenSRF service to control
599
600     --quiet
601         Do not print informational messages to STDOUT 
602
603     --no-daemon
604         Do not detach and run as a daemon process.  Useful for debugging.  
605         Only works for Perl services and only when starting a single service.
606
607     --help
608         Print this help message
609
610     --diagnostic
611         Print information about running services
612
613     ==== starting services =====
614
615     --start-all
616         Start the router and all services
617
618     --start
619         Start the service specified by --service
620
621     --restart-all
622         Restart the router and all services
623
624     --restart
625         Restart the service specified by --service
626
627     --force-clean-process
628         When starting a service, if a service process is already running 
629         but no pidfile exists, kill the service process before starting
630         the new one.
631
632     ==== stopping services =====
633
634     --stop-all
635         Stop the router and all services.  Services are sent the TERM signal,
636         followed by the INT signal, followed by the KILL signal.  With each
637         iteration, the script pauses up to --signal-timeout seconds waiting
638         for each process to die before sending the next signal.
639
640     --stop
641         Stop the service specified by --service.  See also --stop-all.
642         If the requested service does not have a matching PID file, an
643         attempt to locate the PID via 'ps' will be made.
644
645     --graceful-shutdown-all
646         Send TERM signal to all services + router
647
648     --graceful-shutdown
649         Send TERM signal to the service specified by --service
650
651     --fast-shutdown-all
652         Send INT signal to all services + router
653
654     --fast-shutdown
655         Send INT signal to the service specified by --service
656
657     --immediate-shutdown-all
658         Send KILL signal to all services + router
659
660     --immediate-shutdown
661         Send KILL signal to the service specified by --service
662
663     --kill-with-fire
664         Send KILL signal to all running services + routers, regardless of 
665         the presence of a PID file, and remove all PID files indiscriminately.  
666
667     ==== signaling services =====
668
669     --signal-all
670         Send signal to all services
671
672     --signal
673         Name of signal to send.  If --signal-all is not specified, the 
674         signal will be sent to the service specified by --service.
675
676     --signal-timeout
677         Seconds to wait for a process to die after sending a shutdown signal.
678         All signals except HUP, USR1, and USR2 are assumed to be shutdown signals.
679         
680 HELP
681 exit;
682 }
683
684 # we do not verify services for stop/signal actions, since those may
685 # legitimately be used against services not (or no longer) configured
686 # to run on the selected host.
687 do_init() and verify_services($opt_service) if 
688     $opt_start or 
689     $opt_start_all or
690     $opt_restart or
691     $opt_restart_all;
692
693 # starting services.  do_init() handled above
694 do_start($opt_service) if $opt_start;
695 do_stop($opt_service) and do_start($opt_service) if $opt_restart;
696 do_start_all() if $opt_start_all;
697 do_stop_all() and do_start_all() if $opt_restart_all;
698
699 # stopping services
700 do_stop($opt_service) if $opt_stop;
701 do_stop_all() if $opt_stop_all;
702 do_stop($opt_service, 'TERM') if $opt_shutdown_graceful;
703 do_stop($opt_service, 'INT') if $opt_shutdown_fast;
704 do_stop($opt_service, 'KILL') if $opt_shutdown_immediate;
705 do_stop_all('TERM') if $opt_shutdown_graceful_all;
706 do_stop_all('INT') if $opt_shutdown_fast_all;
707 do_stop_all('KILL') if $opt_shutdown_immediate_all;
708 do_kill_with_fire() if $opt_kill_with_fire;
709
710 # signaling
711 do_signal($opt_service, $opt_signal) if $opt_signal;
712 do_signal_all($opt_signal) if $opt_signal_all;
713
714 # misc
715 do_diagnostic() if $opt_diagnostic;
716
717
718 # show help if no action was requested
719 do_help() if $opt_help or not (
720     $opt_start or 
721     $opt_start_all or 
722     $opt_stop or 
723     $opt_stop_all or 
724     $opt_restart or 
725     $opt_restart_all or 
726     $opt_signal or 
727     $opt_signal_all or
728     $opt_shutdown_graceful or
729     $opt_shutdown_graceful_all or
730     $opt_shutdown_fast or
731     $opt_shutdown_fast_all or
732     $opt_shutdown_immediate or
733     $opt_shutdown_immediate_all or
734     $opt_kill_with_fire or
735     $opt_diagnostic
736 )