Write the PID file from the child process (the one that launches the
[OpenSRF.git] / src / libopensrf / osrf_system.c
1 /**
2         @file osrf_system.c
3         @brief Launch a collection of servers.
4 */
5
6 #include <sys/types.h>
7 #include <sys/time.h>
8 #include <unistd.h>
9 #include <stdlib.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include <sys/select.h>
13 #include <sys/wait.h>
14 #include <signal.h>
15
16 #include "opensrf/utils.h"
17 #include "opensrf/log.h"
18 #include "opensrf/osrf_system.h"
19 #include "opensrf/osrf_application.h"
20 #include "opensrf/osrf_prefork.h"
21
22 #ifndef HOST_NAME_MAX
23 #define HOST_NAME_MAX 256
24 #endif
25
26 static void report_child_status( pid_t pid, int status );
27 struct child_node;
28 typedef struct child_node ChildNode;
29
30 /**
31         @brief Represents a child process.
32 */
33 struct child_node
34 {
35         ChildNode* pNext;  /**< Linkage pointer for doubly linked list. */
36         ChildNode* pPrev;  /**< Linkage pointer for doubly linked list. */
37         pid_t pid;         /**< Process ID of the child process. */
38         char* app;
39         char* libfile;
40 };
41
42 /** List of child processes. */
43 static ChildNode* child_list;
44
45 /** Pointer to the global transport_client; i.e. our connection to Jabber. */
46 static transport_client* osrfGlobalTransportClient = NULL;
47
48 /** Switch to be set by signal handler */
49 static volatile sig_atomic_t sig_caught;
50
51 /** Boolean: set to true when we finish shutting down. */
52 static int shutdownComplete = 0;
53
54 /** Name of file to which to write the process ID of the child process */
55 char* pidfile_name = NULL;
56
57 static void add_child( pid_t pid, const char* app, const char* libfile );
58 static void delete_child( ChildNode* node );
59 static void delete_all_children( void );
60 static ChildNode* seek_child( pid_t pid );
61
62 /**
63         @brief Wait on all dead child processes so that they won't be zombies.
64 */
65 static void reap_children( void ) {
66         if( sig_caught ) {
67                 if( SIGTERM == sig_caught || SIGINT == sig_caught ) {
68                         osrfLogInfo( OSRF_LOG_MARK, "Killed by %s; terminating",
69                                         SIGTERM == sig_caught ? "SIGTERM" : "SIGINT" );
70                 } else
71                         osrfLogInfo( OSRF_LOG_MARK, "Killed by signal %d; terminating", (int) sig_caught );
72         }
73
74         // If we caught a signal, then the signal handler already did a kill().
75         // If we didn't, then do the kill() now.
76         if( ! sig_caught )
77                 kill( 0, SIGTERM );
78
79         sleep(1); /* Give the children a chance to die before we reap them. */
80
81         // Wait for each dead child.  The WNOHANG option means to return immediately if
82         // there are no dead children, instead of waiting for them to die.  It is therefore
83         // possible for a child still to be alive when we exit this function, either because
84         // it intercepted the SIGTERM and ignored it, or because it took longer to die than
85         // the time we gave it.
86         pid_t child_pid;
87         while( (child_pid = waitpid(-1, NULL, WNOHANG)) > 0 )
88                 osrfLogInfo(OSRF_LOG_MARK, "Killed child %d", child_pid);
89
90         // Remove all nodes from the list of child processes.
91         delete_all_children();
92 }
93
94 /**
95         @brief Signal handler for SIGTERM and SIGINT.
96
97         Kill all child processes, and set a switch so that we'll know that the signal arrived.
98 */
99 static void handleKillSignal( int signo ) {
100         // First ignore SIGTERM.  Otherwise we would send SIGTERM to ourself, intercept it,
101         // and kill() again in an endless loop.
102         signal( SIGTERM, SIG_IGN );
103
104         //Kill all child processes.  This is safe to do in a signal handler, because POSIX
105         // specifies that kill() is reentrant.  It is necessary because, if we did the kill()
106         // only in reap_children() (above), then there would be a narrow window of vulnerability
107         // in the main loop: if the signal arrives between checking sig_caught and calling wait(),
108         // we would wait indefinitely for a child to die on its own.
109         kill( 0, SIGTERM );
110         sig_caught = signo;
111 }
112
113 /**
114         @brief Return a pointer to the global transport_client.
115         @return Pointer to the global transport_client, or NULL.
116
117         A given process needs only one connection to Jabber, so we keep it a pointer to it at
118         file scope.  This function returns that pointer.
119
120         If the connection has been opened by a previous call to osrfSystemBootstrapClientResc(),
121         return the pointer.  Otherwise return NULL.
122 */
123 transport_client* osrfSystemGetTransportClient( void ) {
124         return osrfGlobalTransportClient;
125 }
126
127 /**
128         @brief Save a copy of a file name to be used for writing a process ID.
129         @param name Designated file name, or NULL.
130
131         Save a file name for later use in saving a process ID.  If @a name is NULL, leave
132         the file name NULL.
133
134         When the parent process spawns a child, the child becomes a daemon.  The parent writes the
135         child's process ID to the PID file, if one has been designated, so that some other process
136         can retrieve the PID later and kill the daemon.
137 */
138 void osrfSystemSetPidFile( const char* name ) {
139         if( pidfile_name )
140                 free( pidfile_name );
141
142         if( name )
143                 pidfile_name = strdup( name );
144         else
145                 pidfile_name = NULL;
146 }
147
148 /**
149         @brief Discard the global transport_client, but without disconnecting from Jabber.
150
151         To be called by a child process in order to disregard the parent's connection without
152         disconnecting it, since disconnecting would disconnect the parent as well.
153 */
154 void osrfSystemIgnoreTransportClient() {
155         client_discard( osrfGlobalTransportClient );
156         osrfGlobalTransportClient = NULL;
157 }
158
159 /**
160         @brief Bootstrap a generic application from info in the configuration file.
161         @param config_file Name of the configuration file.
162         @param contextnode Name of an aggregate within the configuration file, containing the
163         relevant subset of configuration stuff.
164         @return 1 if successful; zero or -1 if error.
165
166         - Load the configuration file.
167         - Open the log.
168         - Open a connection to Jabber.
169
170         A thin wrapper for osrfSystemBootstrapClientResc, passing it NULL for a resource.
171 */
172 int osrf_system_bootstrap_client( char* config_file, char* contextnode ) {
173         return osrfSystemBootstrapClientResc(config_file, contextnode, NULL);
174 }
175
176 /**
177         @brief Connect to one or more cache servers.
178         @return Zero in all cases.
179 */
180 int osrfSystemInitCache( void ) {
181
182         jsonObject* cacheServers = osrf_settings_host_value_object("/cache/global/servers/server");
183         char* maxCache = osrf_settings_host_value("/cache/global/max_cache_time");
184
185         if( cacheServers && maxCache) {
186
187                 if( cacheServers->type == JSON_ARRAY ) {
188                         int i;
189                         const char* servers[cacheServers->size];
190                         for( i = 0; i != cacheServers->size; i++ ) {
191                                 servers[i] = jsonObjectGetString( jsonObjectGetIndex(cacheServers, i) );
192                                 osrfLogInfo( OSRF_LOG_MARK, "Adding cache server %s", servers[i]);
193                         }
194                         osrfCacheInit( servers, cacheServers->size, atoi(maxCache) );
195
196                 } else {
197                         const char* servers[] = { jsonObjectGetString(cacheServers) };
198                         osrfLogInfo( OSRF_LOG_MARK, "Adding cache server %s", servers[0]);
199                         osrfCacheInit( servers, 1, atoi(maxCache) );
200                 }
201
202         } else {
203                 osrfLogError( OSRF_LOG_MARK,  "Missing config value for /cache/global/servers/server _or_ "
204                         "/cache/global/max_cache_time");
205         }
206
207         jsonObjectFree( cacheServers );
208         return 0;
209 }
210
211 /**
212         @brief Launch a collection of servers, as defined by the settings server.
213         @param hostname Full network name of the host where the process is running; or
214         'localhost' will do.
215         @param configfile Name of the configuration file; normally '/openils/conf/opensrf_core.xml'.
216         @param contextNode Name of an aggregate within the configuration file, containing the
217         relevant subset of configuration stuff.
218         @return - Zero if successful, or -1 if not.
219 */
220 int osrfSystemBootstrap( const char* hostname, const char* configfile,
221                 const char* contextNode ) {
222         if( !(hostname && configfile && contextNode) )
223                 return -1;
224
225         // Load the conguration, open the log, open a connection to Jabber
226         if(!osrfSystemBootstrapClientResc(configfile, contextNode, "settings_grabber" )) {
227                 osrfLogError( OSRF_LOG_MARK,
228                         "Unable to bootstrap for host %s from configuration file %s",
229                         hostname, configfile );
230                 return -1;
231         }
232
233         shutdownComplete = 0;
234
235         // Get a list of applications to launch from the settings server
236         int retcode = osrf_settings_retrieve(hostname);
237         osrf_system_disconnect_client();
238
239         if( retcode ) {
240                 osrfLogError( OSRF_LOG_MARK,
241                         "Unable to retrieve settings for host %s from configuration file %s",
242                         hostname, configfile );
243                 return -1;
244         }
245
246         // Turn into a daemon.  The parent forks and exits.  Only the
247         // child returns, with the standard streams (stdin, stdout, and
248         // stderr) redirected to /dev/null.
249         daemonize();
250
251         jsonObject* apps = osrf_settings_host_value_object("/activeapps/appname");
252         osrfStringArray* arr = osrfNewStringArray(8);
253
254         if(apps) {
255                 int i = 0;
256
257                 if(apps->type == JSON_STRING) {
258                         osrfStringArrayAdd(arr, jsonObjectGetString(apps));
259
260                 } else {
261                         const jsonObject* app;
262                         while( (app = jsonObjectGetIndex(apps, i++)) )
263                                 osrfStringArrayAdd(arr, jsonObjectGetString(app));
264                 }
265                 jsonObjectFree(apps);
266
267                 const char* appname = NULL;
268                 int first_launch = 1;             // Boolean
269                 i = 0;
270                 while( (appname = osrfStringArrayGetString(arr, i++)) ) {
271
272                         char* lang = osrf_settings_host_value("/apps/%s/language", appname);
273
274                         if(lang && !strcasecmp(lang,"c"))  {
275
276                                 char* libfile = osrf_settings_host_value("/apps/%s/implementation", appname);
277
278                                 if(! (appname && libfile) ) {
279                                         osrfLogWarning( OSRF_LOG_MARK, "Missing appname / libfile in settings config");
280                                         continue;
281                                 }
282
283                                 osrfLogInfo( OSRF_LOG_MARK, "Launching application %s with implementation %s",
284                                                 appname, libfile);
285
286                                 pid_t pid;
287
288                                 if( (pid = fork()) ) {    // if parent
289                                         // store pid in local list for re-launching dead children...
290                                         add_child( pid, appname, libfile );
291                                         osrfLogInfo( OSRF_LOG_MARK, "Running application child %s: process id %ld",
292                                                                  appname, (long) pid );
293
294                                         if( first_launch ) {
295                                                 if( pidfile_name ) {
296                                                         // Write our own PID to a PID file so that somebody can use it to
297                                                         // send us a signal later.  If we don't find any C apps to launch,
298                                                         // then we will quietly exit without writing a PID file, and without
299                                                         // waiting to be killed by a signal.
300
301                                                         FILE* pidfile = fopen( pidfile_name, "w" );
302                                                         if( !pidfile ) {
303                                                                 osrfLogError( OSRF_LOG_MARK, "Unable to open PID file \"%s\": %s",
304                                                                         pidfile_name, strerror( errno ) );
305                                                                 free( pidfile_name );
306                                                                 pidfile_name = NULL;
307                                                                 return -1;
308                                                         } else {
309                                                                 fprintf( pidfile, "%ld\n", (long) getpid() );
310                                                                 fclose( pidfile );
311                                                         }
312                                                 }
313                                                 first_launch = 0;
314                                         }
315
316                                 } else {         // if child, run the application
317
318                                         osrfLogInfo( OSRF_LOG_MARK, " * Running application %s\n", appname);
319                                         if( pidfile_name ) {
320                                                 free( pidfile_name );    // tidy up some debris from the parent
321                                                 pidfile_name = NULL;
322                                         }
323                                         if( osrfAppRegisterApplication( appname, libfile ) == 0 )
324                                                 osrf_prefork_run(appname);
325
326                                         osrfLogDebug( OSRF_LOG_MARK, "Server exiting for app %s and library %s\n",
327                                                         appname, libfile );
328                                         exit(0);
329                                 }
330                         } // language == c
331                 } // end while
332         }
333
334         osrfStringArrayFree(arr);
335
336         signal(SIGTERM, handleKillSignal);
337         signal(SIGINT, handleKillSignal);
338
339         // Wait indefinitely for all the child processes to terminate, or for a signal to
340         // tell us to stop.  When there are no more child processes, wait() returns an
341         // ECHILD error and we break out of the loop.
342         int status;
343         pid_t pid;
344         while( ! sig_caught ) {
345                 pid = wait( &status );
346                 if( -1 == pid ) {
347                         if( errno == ECHILD )
348                                 osrfLogError( OSRF_LOG_MARK, "We have no more live services... exiting" );
349                         else if( errno != EINTR )
350                                 osrfLogError(OSRF_LOG_MARK, "Exiting top-level system loop with error: %s",
351                                                 strerror( errno ) );
352
353                         // Since we're not being killed by a signal as usual, delete the PID file
354                         // so that no one will try to kill us when we're already dead.
355                         if( pidfile_name )
356                                 remove( pidfile_name );
357                         break;
358                 } else {
359                         report_child_status( pid, status );
360                 }
361         }
362
363         reap_children();
364         osrfConfigCleanup();
365         osrf_system_disconnect_client();
366         osrf_settings_free_host_config(NULL);
367         free( pidfile_name );
368         pidfile_name = NULL;
369         return 0;
370 }
371
372 /**
373         @brief Report the exit status of a dead child process, then remove it from the list.
374         @param pid Process ID of the child.
375         @param status Exit status as captured by wait().
376 */
377 static void report_child_status( pid_t pid, int status )
378 {
379         const char* app;
380         const char* libfile;
381         ChildNode* node = seek_child( pid );
382
383         if( node ) {
384                 app     = node->app     ? node->app     : "[unknown]";
385                 libfile = node->libfile ? node->libfile : "[none]";
386         } else
387                 app = libfile = "";
388
389         if( WIFEXITED( status ) )
390         {
391                 int rc = WEXITSTATUS( status );  // return code of child process
392                 if( rc )
393                         osrfLogError( OSRF_LOG_MARK, "Child process %ld (app %s) exited with return code %d",
394                                         (long) pid, app, rc );
395                 else
396                         osrfLogInfo( OSRF_LOG_MARK, "Child process %ld (app %s) exited normally",
397                                         (long) pid, app );
398         }
399         else if( WIFSIGNALED( status ) )
400         {
401                 osrfLogError( OSRF_LOG_MARK, "Child process %ld (app %s) killed by signal %d",
402                                           (long) pid, app, WTERMSIG( status) );
403         }
404         else if( WIFSTOPPED( status ) )
405         {
406                 osrfLogError( OSRF_LOG_MARK, "Child process %ld (app %s) stopped by signal %d",
407                                           (long) pid, app, (int) WSTOPSIG( status ) );
408         }
409
410         delete_child( node );
411 }
412
413 /*----------- Routines to manage list of children --*/
414
415 /**
416         @brief Add a node to the list of child processes.
417         @param pid Process ID of the child process.
418         @param app Name of the child application.
419         @param libfile Name of the shared library where the child process resides.
420 */
421 static void add_child( pid_t pid, const char* app, const char* libfile )
422 {
423         /* Construct new child node */
424
425         ChildNode* node = safe_malloc( sizeof( ChildNode ) );
426
427         node->pid = pid;
428
429         if( app )
430                 node->app = strdup( app );
431         else
432                 node->app = NULL;
433
434         if( libfile )
435                 node->libfile = strdup( libfile );
436         else
437                 node->libfile = NULL;
438
439         /* Add new child node to the head of the list */
440
441         node->pNext = child_list;
442         node->pPrev = NULL;
443
444         if( child_list )
445                 child_list->pPrev = node;
446
447         child_list = node;
448 }
449
450 /**
451         @brief Remove a node from the list of child processes.
452         @param node Pointer to the node to be removed.
453 */
454 static void delete_child( ChildNode* node ) {
455
456         /* Sanity check */
457
458         if( ! node )
459                 return;
460
461         /* Detach the node from the list */
462
463         if( node->pPrev )
464                 node->pPrev->pNext = node->pNext;
465         else
466                 child_list = node->pNext;
467
468         if( node->pNext )
469                 node->pNext->pPrev = node->pPrev;
470
471         /* Deallocate the node and its payload */
472
473         free( node->app );
474         free( node->libfile );
475         free( node );
476 }
477
478 /**
479         @brief Remove all nodes from the list of child processes, rendering it empty.
480 */
481 static void delete_all_children( void ) {
482
483         while( child_list )
484                 delete_child( child_list );
485 }
486
487 /**
488         @brief Find the node for a child process of a given process ID.
489         @param pid The process ID of the child process.
490         @return A pointer to the corresponding node if found; otherwise NULL.
491 */
492 static ChildNode* seek_child( pid_t pid ) {
493
494         /* Return a pointer to the child node for the */
495         /* specified process ID, or NULL if not found */
496
497         ChildNode* node = child_list;
498         while( node ) {
499                 if( node->pid == pid )
500                         break;
501                 else
502                         node = node->pNext;
503         }
504
505         return node;
506 }
507
508 /*----------- End of routines to manage list of children --*/
509
510 /**
511         @brief Bootstrap a generic application from info in the configuration file.
512         @param config_file Name of the configuration file.
513         @param contextnode Name of an aggregate within the configuration file, containing the
514         relevant subset of configuration stuff.
515         @param resource Used to construct a Jabber resource name; may be NULL.
516         @return 1 if successful; zero or -1 if error.
517
518         - Load the configuration file.
519         - Open the log.
520         - Open a connection to Jabber.
521 */
522 int osrfSystemBootstrapClientResc( const char* config_file,
523                 const char* contextnode, const char* resource ) {
524
525         int failure = 0;
526
527         if(osrfSystemGetTransportClient()) {
528                 osrfLogInfo(OSRF_LOG_MARK, "Client is already bootstrapped");
529                 return 1; /* we already have a client connection */
530         }
531
532         if( !( config_file && contextnode ) && ! osrfConfigHasDefaultConfig() ) {
533                 osrfLogError( OSRF_LOG_MARK, "No Config File Specified\n" );
534                 return -1;
535         }
536
537         if( config_file ) {
538                 osrfConfig* cfg = osrfConfigInit( config_file, contextnode );
539                 if(cfg)
540                         osrfConfigSetDefaultConfig(cfg);
541                 else
542                         return 0;   /* Can't load configuration?  Bail out */
543         }
544
545         char* log_file      = osrfConfigGetValue( NULL, "/logfile");
546         if(!log_file) {
547                 fprintf(stderr, "No log file specified in configuration file %s\n",
548                                 config_file);
549                 return -1;
550         }
551
552         char* log_level      = osrfConfigGetValue( NULL, "/loglevel" );
553         osrfStringArray* arr = osrfNewStringArray(8);
554         osrfConfigGetValueList(NULL, arr, "/domain");
555
556         char* username       = osrfConfigGetValue( NULL, "/username" );
557         char* password       = osrfConfigGetValue( NULL, "/passwd" );
558         char* port           = osrfConfigGetValue( NULL, "/port" );
559         char* unixpath       = osrfConfigGetValue( NULL, "/unixpath" );
560         char* facility       = osrfConfigGetValue( NULL, "/syslog" );
561         char* actlog         = osrfConfigGetValue( NULL, "/actlog" );
562
563         /* if we're a source-client, tell the logger */
564         char* isclient = osrfConfigGetValue(NULL, "/client");
565         if( isclient && !strcasecmp(isclient,"true") )
566                 osrfLogSetIsClient(1);
567         free(isclient);
568
569         int llevel = 0;
570         int iport = 0;
571         if(port) iport = atoi(port);
572         if(log_level) llevel = atoi(log_level);
573
574         if(!strcmp(log_file, "syslog")) {
575                 osrfLogInit( OSRF_LOG_TYPE_SYSLOG, contextnode, llevel );
576                 osrfLogSetSyslogFacility(osrfLogFacilityToInt(facility));
577                 if(actlog) osrfLogSetSyslogActFacility(osrfLogFacilityToInt(actlog));
578
579         } else {
580                 osrfLogInit( OSRF_LOG_TYPE_FILE, contextnode, llevel );
581                 osrfLogSetFile( log_file );
582         }
583
584
585         /* Get a domain, if one is specified */
586         const char* domain = osrfStringArrayGetString( arr, 0 ); /* just the first for now */
587         if(!domain) {
588                 fprintf(stderr, "No domain specified in configuration file %s\n", config_file);
589                 osrfLogError( OSRF_LOG_MARK, "No domain specified in configuration file %s\n",
590                                 config_file );
591                 failure = 1;
592         }
593
594         if(!username) {
595                 fprintf(stderr, "No username specified in configuration file %s\n", config_file);
596                 osrfLogError( OSRF_LOG_MARK, "No username specified in configuration file %s\n",
597                                 config_file );
598                 failure = 1;
599         }
600
601         if(!password) {
602                 fprintf(stderr, "No password specified in configuration file %s\n", config_file);
603                 osrfLogError( OSRF_LOG_MARK, "No password specified in configuration file %s\n",
604                                 config_file);
605                 failure = 1;
606         }
607
608         if((iport <= 0) && !unixpath) {
609                 fprintf(stderr, "No unixpath or valid port in configuration file %s\n", config_file);
610                 osrfLogError( OSRF_LOG_MARK, "No unixpath or valid port in configuration file %s\n",
611                         config_file);
612                 failure = 1;
613         }
614
615         if (failure) {
616                 osrfStringArrayFree(arr);
617                 free(log_file);
618                 free(log_level);
619                 free(username);
620                 free(password);
621                 free(port);
622                 free(unixpath);
623                 free(facility);
624                 free(actlog);
625                 return 0;
626         }
627
628         osrfLogInfo( OSRF_LOG_MARK, "Bootstrapping system with domain %s, port %d, and unixpath %s",
629                 domain, iport, unixpath ? unixpath : "(none)" );
630         transport_client* client = client_init( domain, iport, unixpath, 0 );
631
632         char host[HOST_NAME_MAX + 1] = "";
633         gethostname(host, sizeof(host) );
634         host[HOST_NAME_MAX] = '\0';
635
636         char tbuf[32];
637         tbuf[0] = '\0';
638         snprintf(tbuf, 32, "%f", get_timestamp_millis());
639
640         if(!resource) resource = "";
641
642         int len = strlen(resource) + 256;
643         char buf[len];
644         buf[0] = '\0';
645         snprintf(buf, len - 1, "%s_%s_%s_%ld", resource, host, tbuf, (long) getpid() );
646
647         if(client_connect( client, username, password, buf, 10, AUTH_DIGEST )) {
648                 osrfGlobalTransportClient = client;
649         }
650
651         osrfStringArrayFree(arr);
652         free(actlog);
653         free(facility);
654         free(log_level);
655         free(log_file);
656         free(username);
657         free(password);
658         free(port);
659         free(unixpath);
660
661         if(osrfGlobalTransportClient)
662                 return 1;
663
664         return 0;
665 }
666
667 /**
668         @brief Disconnect from Jabber.
669         @return Zero in all cases.
670 */
671 int osrf_system_disconnect_client( void ) {
672         client_disconnect( osrfGlobalTransportClient );
673         client_free( osrfGlobalTransportClient );
674         osrfGlobalTransportClient = NULL;
675         return 0;
676 }
677
678 /**
679         @brief Shut down a laundry list of facilities typically used by servers.
680
681         Things to shut down:
682         - Settings from configuration file
683         - Cache
684         - Connection to Jabber
685         - Settings from settings server
686         - Application sessions
687         - Logs
688 */
689 int osrf_system_shutdown( void ) {
690         if(shutdownComplete)
691                 return 0;
692         else {
693                 osrfConfigCleanup();
694                 osrfCacheCleanup();
695                 osrf_system_disconnect_client();
696                 osrf_settings_free_host_config(NULL);
697                 osrfAppSessionCleanup();
698                 osrfLogCleanup();
699                 shutdownComplete = 1;
700                 return 1;
701         }
702 }