changed router binary to opensrf_router to prevent opensrf_all from destroying
[OpenSRF.git] / src / perlmods / OpenSRF / System.pm
1 package OpenSRF::System;
2 use strict; use warnings;
3 use base 'OpenSRF';
4 use OpenSRF::Utils::Logger qw(:level);
5 use OpenSRF::Transport::Listener;
6 use OpenSRF::Transport;
7 use OpenSRF::UnixServer;
8 use OpenSRF::Utils;
9 use OpenSRF::Utils::LogServer;
10 use OpenSRF::DOM;
11 use OpenSRF::EX qw/:try/;
12 use POSIX ":sys_wait_h";
13 use OpenSRF::Utils::Config; 
14 use OpenSRF::Utils::SettingsParser;
15 use OpenSRF::Utils::SettingsClient;
16 use OpenSRF::Application;
17 use Net::Server::PreFork;
18 use strict;
19
20 my $bootstrap_config_file;
21 sub import {
22         my( $self, $config ) = @_;
23         $bootstrap_config_file = $config;
24 }
25
26 =head2 Name/Description
27
28 OpenSRF::System
29
30 To start the system: OpenSRF::System->bootstrap();
31
32 Simple system process management and automation.  After instantiating the class, simply call
33 bootstrap() to launch the system.  Each launched process is stored as a process-id/method-name
34 pair in a local hash.  When we receive a SIG{CHILD}, we loop through this hash and relaunch
35 any child processes that may have terminated.  
36
37 Currently automated processes include launching the internal Unix Servers, launching the inbound 
38 connections for each application, and starting the system shell.
39
40
41 Note: There should be only one instance of this class
42 alive at any given time.  It is designed as a globel process handler and, hence, will cause much
43 oddness if you call the bootstrap() method twice or attempt to create two of these by trickery.
44 There is a single instance of the class created on the first call to new().  This same instance is 
45 returned on subsequent calls to new().
46
47 =cut
48
49 $| = 1;
50
51 sub DESTROY {}
52
53 # ----------------------------------------------
54
55 $SIG{INT} = sub { instance()->killall(); };
56
57 $SIG{HUP} = sub{ instance()->hupall(); };
58
59 #$SIG{CHLD} = \&process_automation;
60
61
62
63         # --- 
64         # put $instance in a closure and return it for requests to new()
65         # since there should only be one System instance running
66         # ----- 
67         my $instance;
68         sub instance { return __PACKAGE__->new(); }
69         sub new {
70                 my( $class ) = @_;
71
72                 if( ! $instance ) {
73                         $class = ref( $class ) || $class;
74                         my $self = {};
75                         $self->{'pid_hash'} = {};
76                         bless( $self, $class );
77                         $instance = $self;
78                 }
79                 return $instance;
80         }
81 }
82
83 # ----------------------------------------------
84 # Commands to execute at system launch
85
86 sub _unixserver {
87         my( $app ) = @_;
88         return "OpenSRF::UnixServer->new( '$app')->serve()";
89 }
90
91 sub _listener {
92         my( $app ) = @_;
93         return "OpenSRF::Transport::Listener->new( '$app' )->initialize()->listen()";
94 }
95
96
97 # ----------------------------------------------
98 # Boot up the system
99
100 sub load_bootstrap_config {
101
102         if(OpenSRF::Utils::Config->current) {
103                 return;
104         }
105
106         warn "Loading $bootstrap_config_file\n";
107         if(!$bootstrap_config_file) {
108                 die "Please provide a bootstrap config file to OpenSRF::System!\n" . 
109                         "use OpenSRF::System qw(/path/to/bootstrap_config);";
110         }
111
112         OpenSRF::Utils::Config->load( config_file => $bootstrap_config_file );
113
114         JSON->register_class_hint( name => "OpenSRF::Application", hint => "method", type => "hash" );
115
116         OpenSRF::Transport->message_envelope(  "OpenSRF::Transport::SlimJabber::MessageWrapper" );
117         OpenSRF::Transport::PeerHandle->set_peer_client(  "OpenSRF::Transport::SlimJabber::PeerConnection" );
118         OpenSRF::Transport::Listener->set_listener( "OpenSRF::Transport::SlimJabber::Inbound" );
119         OpenSRF::Application->server_class('client');
120 }
121
122 sub bootstrap {
123
124         my $self = __PACKAGE__->instance();
125         load_bootstrap_config();
126         OpenSRF::Utils::Logger::set_config();
127         my $bsconfig = OpenSRF::Utils::Config->current;
128
129         # Start a process group and make me the captain
130         setpgrp( 0, 0 ); 
131         $0 = "OpenSRF System";
132
133         # -----------------------------------------------
134         # Launch the settings sever if necessary...
135         my $are_settings_server = 0;
136         if( (my $cfile = $bsconfig->bootstrap->settings_config) ) {
137                 my $parser = OpenSRF::Utils::SettingsParser->new();
138
139                 # since we're (probably) the settings server, we can go ahead and load the real config file
140                 $parser->initialize( $cfile );
141                 $OpenSRF::Utils::SettingsClient::host_config = 
142                         $parser->get_server_config($bsconfig->env->hostname);
143
144                 my $client = OpenSRF::Utils::SettingsClient->new();
145                 my $apps = $client->config_value("activeapps", "appname");
146                 if(ref($apps) ne "ARRAY") { $apps = [$apps]; }
147
148                 if(!defined($apps) || @$apps == 0) {
149                         print "No apps to load, exiting...";
150                         return;
151                 }
152
153                 for my $app (@$apps) {
154                         # verify we are a settings server and launch 
155                         if( $app eq "opensrf.settings" ) {
156                                 $are_settings_server = 1;
157                                 $self->launch_settings();
158                                 sleep 1;
159                                 $self->launch_settings_listener();
160                                 last;
161                         } 
162                 }
163         }
164
165         # Launch everything else
166         my $client = OpenSRF::Utils::SettingsClient->new();
167         my $apps = $client->config_value("activeapps", "appname" );
168         if(!ref($apps)) { $apps = [$apps]; }
169
170         if(!defined($apps) || @$apps == 0) {
171                 print "No apps to load, exiting...";
172                 return;
173         }
174
175         my $server_type = $client->config_value("server_type");
176         $server_type ||= "basic";
177
178         my $con = OpenSRF::Transport::PeerHandle->retrieve;
179         if($con) {
180                 $con->disconnect;
181         }
182
183
184
185         if(  $server_type eq "prefork" ) { 
186                 $server_type = "Net::Server::PreFork"; 
187         } else { 
188                 $server_type = "Net::Server::Single"; 
189         }
190
191         _log( " * Server type: $server_type", INTERNAL );
192
193         eval "use $server_type";
194
195         if( $@ ) {
196                 throw OpenSRF::EX::PANIC ("Cannot set $server_type: $@" );
197         }
198
199         push @OpenSRF::UnixServer::ISA, $server_type;
200
201         _log( " * System boostrap" );
202         
203         # --- Boot the Unix servers
204         $self->launch_unix($apps);
205
206
207         _sleep();
208         sleep 2;
209
210         # --- Boot the listeners
211         $self->launch_listener($apps);
212
213         _sleep();
214
215         _log( " * System is ready..." );
216
217         sleep 1;
218         my $ps = `ps ax | grep " Open" | grep -v grep | sort -r -k5`;
219
220         print "\n --- PS --- \n$ps --- PS ---\n\n";
221
222         while( 1 ) { sleep; }
223         exit;
224 }
225         
226         
227
228 # ----------------------------------------------
229 # Bootstraps a single client connection.  
230
231 # named params are 'config_file' and 'client_name'
232 #
233 sub bootstrap_client {
234         my $self = shift;
235
236         my %params = @_;
237
238         $bootstrap_config_file = 
239                 $params{config_file} || $bootstrap_config_file;
240
241         my $app = $params{client_name} || "client";
242
243
244         load_bootstrap_config();
245         OpenSRF::Utils::Logger::set_config();
246         OpenSRF::Transport::PeerHandle->construct( $app );
247
248 }
249
250 sub bootstrap_logger {
251         $0 = "Log Server";
252         OpenSRF::Utils::LogServer->serve();
253 }
254
255
256 # ----------------------------------------------
257 # Cycle through the known processes, reap the dead child 
258 # and put a new child in its place. (MMWWAHAHHAHAAAA!)
259
260 sub process_automation {
261
262         my $self = __PACKAGE__->instance();
263
264         foreach my $pid ( keys %{$self->pid_hash} ) {
265
266                 if( waitpid( $pid, WNOHANG ) == $pid ) {
267
268                         my $method = $self->pid_hash->{$pid};
269                         delete $self->pid_hash->{$pid};
270
271                         my $newpid =  OpenSRF::Utils::safe_fork();
272
273                         OpenSRF::Utils::Logger->debug( "Relaunching $method", ERROR );
274                         _log( "Relaunching => $method" );
275
276                         if( $newpid ) {
277                                 $self->pid_hash( $newpid, $method );
278                         }
279                         else { eval $method; exit; }
280                 }
281         }
282
283         $SIG{CHLD} = \&process_automation;
284 }
285
286
287
288 sub launch_settings {
289
290         #       XXX the $self like this and pid automation will not work with this setup....
291         my($self) = @_;
292         @OpenSRF::UnixServer::ISA = qw(OpenSRF Net::Server::PreFork);
293
294         my $pid = OpenSRF::Utils::safe_fork();
295         if( $pid ) {
296                 $self->pid_hash( $pid , "launch_settings()" );
297         }
298         else {
299                 my $apname = "opensrf.settings";
300                 #$0 = "OpenSRF App [$apname]";
301                 eval _unixserver( $apname );
302                 if($@) { die "$@\n"; }
303                 exit;
304         }
305
306         @OpenSRF::UnixServer::ISA = qw(OpenSRF);
307
308 }
309
310
311 sub launch_settings_listener {
312
313         my $self = shift;
314         my $app = "opensrf.settings";
315         my $pid = OpenSRF::Utils::safe_fork();
316         if ( $pid ) {
317                 $self->pid_hash( $pid , _listener( $app ) );
318         }
319         else {
320                 my $apname = $app;
321                 $0 = "OpenSRF listener [$apname]";
322                 eval _listener( $app );
323                 exit;
324         }
325
326 }
327
328 # ----------------------------------------------
329 # Launch the Unix Servers
330
331 sub launch_unix {
332         my( $self, $apps ) = @_;
333
334         foreach my $app ( @$apps ) {
335                 next unless $app;
336
337                 if( $app eq "opensrf.settings" ) { next; }
338
339                 _log( " * Starting UnixServer for $app..." );
340
341                 my $pid = OpenSRF::Utils::safe_fork();
342                 if( $pid ) {
343                         $self->pid_hash( $pid , _unixserver( $app ) );
344                 }
345                 else {
346                         my $apname = $app;
347                         $0 = "OpenSRF App ($apname)";
348                         eval _unixserver( $app );
349                         exit;
350                 }
351         }
352 }
353
354 # ----------------------------------------------
355 # Launch the inbound clients
356
357 sub launch_listener {
358
359         my( $self, $apps ) = @_;
360
361         foreach my $app ( @$apps ) {
362
363                 next unless defined($app);
364
365                 if( $app eq "opensrf.settings" ) { next; }
366
367                 _log( " * Starting Listener for $app..." );
368
369                 my $pid = OpenSRF::Utils::safe_fork();
370                 if ( $pid ) {
371                         $self->pid_hash( $pid , _listener( $app ) );
372                 }
373                 else {
374                         my $apname = $app;
375                         $0 = "OpenSRF listener [$apname]";
376                         eval _listener( $app );
377                         exit;
378                 }
379         }
380 }
381
382 # ----------------------------------------------
383
384 =head comment
385 sub launch_shell {
386
387         my $self = shift;
388
389         my $pid = OpenSRF::Utils::safe_fork();
390
391         if( $pid ) { $self->pid_hash( $pid , _shell() ); }
392         else {
393                 $0 = "System Shell";
394                 for( my $x = 0; $x != 10; $x++ ) {
395                         eval _shell();
396                         if( ! $@ ) { last; }
397                 }
398                 exit;
399         }
400 }
401 =cut
402
403
404 # ----------------------------------------------
405
406 sub pid_hash {
407         my( $self, $pid, $method ) = @_;
408         $self->{'pid_hash'}->{$pid} = $method
409                 if( $pid and $method );
410         return $self->{'pid_hash'};
411 }
412
413 # ----------------------------------------------
414 # If requested, the System can shut down.
415
416 sub killall {
417
418         $SIG{CHLD} = 'IGNORE';
419         $SIG{INT} = 'IGNORE';
420         kill( 'INT', -$$ ); #kill all in process group
421         exit;
422
423 }
424
425 # ----------------------------------------------
426 # Handle $SIG{HUP}
427 sub hupall {
428
429         _log( "HUPping brood" );
430         $SIG{CHLD} = 'IGNORE';
431         $SIG{HUP} = 'IGNORE';
432         set_config(); # reload config
433         kill( 'HUP', -$$ );
434 #       $SIG{CHLD} = \&process_automation;
435         $SIG{HUP} = sub{ instance()->hupall(); };
436 }
437
438
439 # ----------------------------------------------
440 # Log to debug, and stdout
441
442 sub _log {
443         my $string = shift;
444         OpenSRF::Utils::Logger->debug( $string, INFO );
445         print $string . "\n";
446 }
447
448 # ----------------------------------------------
449
450 sub _sleep {
451         select( undef, undef, undef, 0.3 );
452 }
453
454 1;
455
456