Rename 'all_deps_stopped' function to 'bring_down'.
[oweals/dinit.git] / src / service.h
1 #ifndef SERVICE_H
2 #define SERVICE_H
3
4 #include <string>
5 #include <list>
6 #include <vector>
7 #include <csignal>
8 #include <unordered_set>
9 #include <algorithm>
10
11 #include "dasynq.h"
12
13 #include "control.h"
14 #include "service-listener.h"
15 #include "service-constants.h"
16 #include "dinit-ll.h"
17
18 /*
19  * This header defines service_record, a data record maintaining information about a service,
20  * and service_set, a set of interdependent service records. It also defines some associated
21  * types and exceptions.
22  *
23  * Service states
24  * --------------
25  * Services have both a current state and a desired state. The desired state can be
26  * either STARTED or STOPPED. The current state can also be STARTING or STOPPING.
27  * A service can be "pinned" in either the STARTED or STOPPED states to prevent it
28  * from leaving that state until it is unpinned.
29  *
30  * The total state is a combination of the two, current and desired:
31  *      STOPPED/STOPPED  : stopped and will remain stopped
32  *      STOPPED/STARTED  : stopped (pinned), must be unpinned to start
33  *      STARTING/STARTED : starting, but not yet started. Dependencies may also be starting.
34  *      STARTING/STOPPED : as above, but the service will be stopped again as soon as it has
35  *                         completed startup.
36  *      STARTED/STARTED  : running and will continue running.
37  *      STARTED/STOPPED  : started (pinned), must be unpinned to stop
38  *      STOPPING/STOPPED : stopping and will stop. Dependents may be stopping.
39  *      STOPPING/STARTED : as above, but the service will be re-started again once it stops.
40  *
41  * A scripted service is in the STARTING/STOPPING states during the script execution.
42  * A process service is in the STOPPING state when it has been signalled to stop, and is
43  * in the STARTING state when waiting for dependencies to start or for the exec() call in
44  * the forked child to complete and return a status.
45  *
46  * Acquisition/release:
47  * ------------------
48  * Each service has a dependent-count ("required_by"). This starts at 0, adds 1 if the
49  * service has explicitly been started (i.e. "start_explicit" is true), and adds 1 for
50  * each dependent service which is not STOPPED (including dependents with a soft dependency).
51  * When required_by transitions to 0, the service is stopped (unless it is pinned). When
52  * require_by transitions from 0, the service is started (unless pinned).
53  *
54  * So, in general, the dependent-count determines the desired state (STARTED if the count
55  * is greater than 0, otherwise STOPPED). However, a service can be issued a stop-and-take
56  * down order (via `stop(true)'); this will first stop dependent services, which may restart
57  * and cancel the stop of the former service. Finally, a service can be force-stopped, which
58  * means that its stop process cannot be cancelled (though it may still be put in a desired
59  * state of STARTED, meaning it will start immediately upon stopping).
60  *
61  * Pinning
62  * -------
63  * A service may be "pinned" in either STARTED or STOPPED states (or even both). Once it
64  * reaches a pinned state, a service will not leave that state, though its desired state
65  * may still be set. (Note that pinning prevents, but never causes, state transition).
66  *
67  * The priority of the different state deciders is:
68  *  - pins
69  *  - force stop flag
70  *  - desired state (which is manipulated by require/release operations)
71  *
72  * So a forced stop cannot occur until the service is not pinned started, for instance.
73  *
74  * Two-phase transition
75  * --------------------
76  * Transition between states occurs in two phases: propagation and execution. In both phases
77  * a linked-list queue is used to keep track of which services need processing; this avoids
78  * recursion (which would be of unknown depth and therefore liable to stack overflow).
79  *
80  * In the propagation phase, acquisition/release messages are processed, and desired state may be
81  * altered accordingly. Start and stop requests are also propagated in this phase. The state may
82  * be set to STARTING or STOPPING to reflect the desired state, but will never be set to STARTED
83  * or STOPPED (that happens in the execution phase).
84  *
85  * Propagation variables:
86  *   prop_acquire:  the service has transitioned to an acquired state and must issue an acquire
87  *                  on its dependencies
88  *   prop_release:  the service has transitioned to a released state and must issue a release on
89  *                  its dependencies.
90  *
91  *   prop_start:    the service should start
92  *   prop_stop:     the service should stop
93  *
94  * Note that "prop_acquire"/"prop_release" form a pair which cannot both be set at the same time
95  * which is enforced via explicit checks. For "prop_start"/"prop_stop" this occurs implicitly.
96  *
97  * In the execution phase, actions are taken to achieve the desired state. Actual state may
98  * transition according to the current and desired states. Processes can be sent signals, etc
99  * in order to stop them. A process can restart if it stops, but it does so by raising prop_start
100  * which needs to be processed in a second transition phase. Seeing as starting never causes
101  * another process to stop, the transition-execute-transition cycle always ends at the 2nd
102  * transition stage, at the latest.
103  */
104
105 struct onstart_flags_t {
106     bool rw_ready : 1;  // file system should be writable once this service starts
107     bool log_ready : 1; // syslog should be available once this service starts
108     
109     // Not actually "onstart" commands:
110     bool no_sigterm : 1;  // do not send SIGTERM
111     bool runs_on_console : 1;  // run "in the foreground"
112     bool starts_on_console : 1; // starts in the foreground
113     bool pass_cs_fd : 1;  // pass this service a control socket connection via fd
114     
115     onstart_flags_t() noexcept : rw_ready(false), log_ready(false),
116             no_sigterm(false), runs_on_console(false), starts_on_console(false), pass_cs_fd(false)
117     {
118     }
119 };
120
121 // Exception while loading a service
122 class service_load_exc
123 {
124     public:
125     std::string serviceName;
126     std::string excDescription;
127     
128     protected:
129     service_load_exc(std::string serviceName, std::string &&desc) noexcept
130         : serviceName(serviceName), excDescription(std::move(desc))
131     {
132     }
133 };
134
135 class service_not_found : public service_load_exc
136 {
137     public:
138     service_not_found(std::string serviceName) noexcept
139         : service_load_exc(serviceName, "Service description not found.")
140     {
141     }
142 };
143
144 class service_cyclic_dependency : public service_load_exc
145 {
146     public:
147     service_cyclic_dependency(std::string serviceName) noexcept
148         : service_load_exc(serviceName, "Has cyclic dependency.")
149     {
150     }
151 };
152
153 class service_description_exc : public service_load_exc
154 {
155     public:
156     service_description_exc(std::string serviceName, std::string &&extraInfo) noexcept
157         : service_load_exc(serviceName, std::move(extraInfo))
158     {
159     }    
160 };
161
162 class service_record;
163 class service_set;
164 class base_process_service;
165
166 enum class dependency_type
167 {
168     REGULAR,
169     SOFT,       // dependency starts in parallel, failure/stop does not affect dependent
170     WAITS_FOR,  // as for SOFT, but dependent waits until dependency starts/fails before starting
171     MILESTONE   // dependency must start successfully, but once started the dependency becomes soft
172 };
173
174 /* Service dependency record */
175 class service_dep
176 {
177     service_record * from;
178     service_record * to;
179
180     public:
181     /* Whether the 'from' service is waiting for the 'to' service to start */
182     bool waiting_on;
183     /* Whether the 'from' service is holding an acquire on the 'to' service */
184     bool holding_acq;
185
186     const dependency_type dep_type;
187
188     service_dep(service_record * from, service_record * to, dependency_type dep_type_p) noexcept
189             : from(from), to(to), waiting_on(false), holding_acq(false), dep_type(dep_type_p)
190     {  }
191
192     service_record * get_from() noexcept
193     {
194         return from;
195     }
196
197     service_record * get_to() noexcept
198     {
199         return to;
200     }
201 };
202
203 /* preliminary service dependency information */
204 class prelim_dep
205 {
206     public:
207     service_record * const to;
208     dependency_type const dep_type;
209
210     prelim_dep(service_record *to_p, dependency_type dep_type_p) : to(to_p), dep_type(dep_type_p)
211     {
212         //
213     }
214 };
215
216 // Given a string and a list of pairs of (start,end) indices for each argument in that string,
217 // store a null terminator for the argument. Return a `char *` vector containing the beginning
218 // of each argument and a trailing nullptr. (The returned array is invalidated if the string is later modified).
219 static std::vector<const char *> separate_args(std::string &s, std::list<std::pair<unsigned,unsigned>> &arg_indices)
220 {
221     std::vector<const char *> r;
222     r.reserve(arg_indices.size() + 1);
223
224     // First store nul terminator for each part:
225     for (auto index_pair : arg_indices) {
226         if (index_pair.second < s.length()) {
227             s[index_pair.second] = 0;
228         }
229     }
230
231     // Now we can get the C string (c_str) and store offsets into it:
232     const char * cstr = s.c_str();
233     for (auto index_pair : arg_indices) {
234         r.push_back(cstr + index_pair.first);
235     }
236     r.push_back(nullptr);
237     return r;
238 }
239
240 class service_child_watcher : public eventloop_t::child_proc_watcher_impl<service_child_watcher>
241 {
242     public:
243     base_process_service * service;
244     rearm status_change(eventloop_t &eloop, pid_t child, int status) noexcept;
245     
246     service_child_watcher(base_process_service * sr) noexcept : service(sr) { }
247 };
248
249 // Watcher for the pipe used to receive exec() failure status errno
250 class exec_status_pipe_watcher : public eventloop_t::fd_watcher_impl<exec_status_pipe_watcher>
251 {
252     public:
253     base_process_service * service;
254     rearm fd_event(eventloop_t &eloop, int fd, int flags) noexcept;
255     
256     exec_status_pipe_watcher(base_process_service * sr) noexcept : service(sr) { }
257 };
258
259 // service_record: base class for service record containing static information
260 // and current state of each service.
261 class service_record
262 {
263     protected:
264     typedef std::string string;
265     
266     string service_name;
267     service_type record_type;  /* ServiceType::DUMMY, PROCESS, SCRIPTED, INTERNAL */
268     service_state_t service_state = service_state_t::STOPPED; /* service_state_t::STOPPED, STARTING, STARTED, STOPPING */
269     service_state_t desired_state = service_state_t::STOPPED; /* service_state_t::STOPPED / STARTED */
270
271     string program_name;          // storage for program/script and arguments
272     std::vector<const char *> exec_arg_parts; // pointer to each argument/part of the program_name, and nullptr
273     
274     string stop_command;          // storage for stop program/script and arguments
275     std::vector<const char *> stop_arg_parts; // pointer to each argument/part of the stop_command, and nullptr
276     
277     string pid_file;
278     
279     onstart_flags_t onstart_flags;
280
281     string logfile;           // log file name, empty string specifies /dev/null
282     
283     bool auto_restart : 1;    // whether to restart this (process) if it dies unexpectedly
284     bool smooth_recovery : 1; // whether the service process can restart without bringing down service
285     
286     bool pinned_stopped : 1;
287     bool pinned_started : 1;
288     bool waiting_for_deps : 1;  // if STARTING, whether we are waiting for dependencies (inc console) to start
289                                 // if STOPPING, whether we are waiting for dependents to stop
290     bool waiting_for_execstat : 1;  // if we are waiting for exec status after fork()
291     bool start_explicit : 1;    // whether we are are explicitly required to be started
292
293     bool prop_require : 1;      // require must be propagated
294     bool prop_release : 1;      // release must be propagated
295     bool prop_failure : 1;      // failure to start must be propagated
296     bool prop_start   : 1;
297     bool prop_stop    : 1;
298
299     bool restarting   : 1;      // re-starting after unexpected termination
300     
301     int required_by = 0;        // number of dependents wanting this service to be started
302
303     // list of dependencies
304     typedef std::list<service_dep> dep_list;
305     
306     // list of dependents
307     typedef std::list<service_dep *> dpt_list;
308     
309     dep_list depends_on;  // services this one depends on
310     dpt_list dependents;  // services depending on this one
311     
312     service_set *services; // the set this service belongs to
313     
314     std::unordered_set<service_listener *> listeners;
315     
316     // Process services:
317     bool force_stop; // true if the service must actually stop. This is the
318                      // case if for example the process dies; the service,
319                      // and all its dependencies, MUST be stopped.
320     
321     int term_signal = -1;  // signal to use for process termination
322     
323     string socket_path; // path to the socket for socket-activation service
324     int socket_perms;   // socket permissions ("mode")
325     uid_t socket_uid = -1;  // socket user id or -1
326     gid_t socket_gid = -1;  // socket group id or -1
327
328     // Implementation details
329     
330     pid_t pid = -1;  // PID of the process. If state is STARTING or STOPPING,
331                      //   this is PID of the service script; otherwise it is the
332                      //   PID of the process itself (process service).
333     int exit_status; // Exit status, if the process has exited (pid == -1).
334     int socket_fd = -1;  // For socket-activation services, this is the file
335                          // descriptor for the socket.
336     
337     // Data for use by service_set
338     public:
339     
340     // Console queue.
341     lld_node<service_record> console_queue_node;
342     
343     // Propagation and start/stop queues
344     lls_node<service_record> prop_queue_node;
345     lls_node<service_record> stop_queue_node;
346     
347     protected:
348     
349     // stop immediately
350     void emergency_stop() noexcept;
351
352     // All dependents have stopped, and this service should proceed to stop.
353     virtual void bring_down() noexcept;
354     
355     // Service has actually stopped (includes having all dependents
356     // reaching STOPPED state).
357     void stopped() noexcept;
358     
359     // Service has successfully started
360     void started() noexcept;
361     
362     // Service failed to start (only called when in STARTING state).
363     //   dep_failed: whether failure is recorded due to a dependency failing
364     void failed_to_start(bool dep_failed = false) noexcept;
365
366     void run_child_proc(const char * const *args, const char *logfile, bool on_console, int wpipefd,
367             int csfd) noexcept;
368     
369     // A dependency has reached STARTED state
370     void dependency_started() noexcept;
371     
372     void all_deps_started(bool haveConsole = false) noexcept;
373
374     // Do any post-dependency startup; return false on failure
375     virtual bool start_ps_process() noexcept;
376
377     // Open the activation socket, return false on failure
378     bool open_socket() noexcept;
379
380     // Start all dependencies, return true if all have started
381     bool start_check_dependencies() noexcept;
382
383     // Check whether all dependencies have started (i.e. whether we can start now)
384     bool check_deps_started() noexcept;
385
386     // Whether a STARTING service can immediately transition to STOPPED (as opposed to
387     // having to wait for it reach STARTED and then go through STOPPING).
388     virtual bool can_interrupt_start() noexcept
389     {
390         return waiting_for_deps;
391     }
392     
393     // Whether a STARTING service can transition to its STARTED state, once all
394     // dependencies have started.
395     virtual bool can_proceed_to_start() noexcept
396     {
397         return true;
398     }
399
400     virtual void interrupt_start() noexcept;
401
402     // Whether a STOPPING service can immediately transition to STARTED.
403     bool can_interrupt_stop() noexcept
404     {
405         return waiting_for_deps && ! force_stop;
406     }
407
408     // A dependent has reached STOPPED state
409     void dependent_stopped() noexcept;
410
411     // check if all dependents have stopped
412     bool stop_check_dependents() noexcept;
413     
414     // issue a stop to all dependents, return true if they are all already stopped
415     bool stop_dependents() noexcept;
416     
417     void require() noexcept;
418     void release() noexcept;
419     void release_dependencies() noexcept;
420     
421     // Check if service is, fundamentally, stopped.
422     bool is_stopped() noexcept
423     {
424         return service_state == service_state_t::STOPPED
425             || (service_state == service_state_t::STARTING && waiting_for_deps);
426     }
427     
428     void notify_listeners(service_event_t event) noexcept
429     {
430         for (auto l : listeners) {
431             l->service_event(this, event);
432         }
433     }
434     
435     // Queue to run on the console. 'acquired_console()' will be called when the console is available.
436     // Has no effect if the service has already queued for console.
437     void queue_for_console() noexcept;
438     
439     // Release console (console must be currently held by this service)
440     void release_console() noexcept;
441     
442     bool do_auto_restart() noexcept;
443
444     // Started state reached
445     bool process_started() noexcept;
446
447     // Called on transition of desired state from stopped to started (or unpinned stop)
448     void do_start() noexcept;
449
450     // Called on transition of desired state from started to stopped (or unpinned start)
451     void do_stop() noexcept;
452
453     public:
454
455     service_record(service_set *set, string name)
456         : service_state(service_state_t::STOPPED), desired_state(service_state_t::STOPPED),
457             auto_restart(false), smooth_recovery(false),
458             pinned_stopped(false), pinned_started(false), waiting_for_deps(false),
459             waiting_for_execstat(false), start_explicit(false),
460             prop_require(false), prop_release(false), prop_failure(false),
461             prop_start(false), prop_stop(false), restarting(false), force_stop(false)
462     {
463         services = set;
464         service_name = name;
465         record_type = service_type::DUMMY;
466         socket_perms = 0;
467         exit_status = 0;
468     }
469
470     service_record(service_set *set, string name, service_type record_type_p,
471             const std::list<prelim_dep> &deplist_p)
472         : service_record(set, name)
473     {
474         services = set;
475         service_name = name;
476         this->record_type = record_type_p;
477
478         for (auto & pdep : deplist_p) {
479             auto b = depends_on.emplace(depends_on.end(), this, pdep.to, pdep.dep_type);
480             pdep.to->dependents.push_back(&(*b));
481         }
482     }
483     
484     service_record(service_set *set, string name, service_type record_type_p, string &&command,
485             std::list<std::pair<unsigned,unsigned>> &command_offsets,
486             const std::list<prelim_dep> &deplist_p)
487         : service_record(set, name, record_type_p, deplist_p)
488     {
489         program_name = std::move(command);
490         exec_arg_parts = separate_args(program_name, command_offsets);
491     }
492     
493     virtual ~service_record() noexcept
494     {
495     }
496     
497     // begin transition from stopped to started state or vice versa depending on current and desired state
498     void execute_transition() noexcept;
499     
500     void do_propagation() noexcept;
501
502     // Console is available.
503     void acquired_console() noexcept;
504     
505     // Set the stop command and arguments (may throw std::bad_alloc)
506     void set_stop_command(std::string command, std::list<std::pair<unsigned,unsigned>> &stop_command_offsets)
507     {
508         stop_command = command;
509         stop_arg_parts = separate_args(stop_command, stop_command_offsets);
510     }
511     
512     // Get the target (aka desired) state.
513     service_state_t get_target_state() noexcept
514     {
515         return desired_state;
516     }
517
518     // Set logfile, should be done before service is started
519     void set_log_file(string logfile)
520     {
521         this->logfile = logfile;
522     }
523     
524     // Set whether this service should automatically restart when it dies
525     void set_auto_restart(bool auto_restart) noexcept
526     {
527         this->auto_restart = auto_restart;
528     }
529     
530     void set_smooth_recovery(bool smooth_recovery) noexcept
531     {
532         this->smooth_recovery = smooth_recovery;
533     }
534     
535     // Set "on start" flags (commands)
536     void set_flags(onstart_flags_t flags) noexcept
537     {
538         this->onstart_flags = flags;
539     }
540     
541     // Set an additional signal (other than SIGTERM) to be used to terminate the process
542     void set_extra_termination_signal(int signo) noexcept
543     {
544         this->term_signal = signo;
545     }
546     
547     void set_pid_file(string &&pid_file) noexcept
548     {
549         this->pid_file = std::move(pid_file);
550     }
551     
552     void set_socket_details(string &&socket_path, int socket_perms, uid_t socket_uid, uid_t socket_gid) noexcept
553     {
554         this->socket_path = std::move(socket_path);
555         this->socket_perms = socket_perms;
556         this->socket_uid = socket_uid;
557         this->socket_gid = socket_gid;
558     }
559
560     const std::string &get_service_name() const noexcept { return service_name; }
561     service_state_t get_state() const noexcept { return service_state; }
562     
563     void start(bool activate = true) noexcept;  // start the service
564     void stop(bool bring_down = true) noexcept;   // stop the service
565     
566     void forced_stop() noexcept; // force-stop this service and all dependents
567     
568     // Pin the service in "started" state (when it reaches the state)
569     void pin_start() noexcept
570     {
571         pinned_started = true;
572     }
573     
574     // Pin the service in "stopped" state (when it reaches the state)
575     void pin_stop() noexcept
576     {
577         pinned_stopped = true;
578     }
579     
580     // Remove both "started" and "stopped" pins. If the service is currently pinned
581     // in either state but would naturally be in the opposite state, it will immediately
582     // commence starting/stopping.
583     void unpin() noexcept;
584     
585     bool isDummy() noexcept
586     {
587         return record_type == service_type::DUMMY;
588     }
589     
590     // Add a listener. A listener must only be added once. May throw std::bad_alloc.
591     void addListener(service_listener * listener)
592     {
593         listeners.insert(listener);
594     }
595     
596     // Remove a listener.    
597     void removeListener(service_listener * listener) noexcept
598     {
599         listeners.erase(listener);
600     }
601 };
602
603 class base_process_service;
604
605 // A timer for process restarting. Used to ensure a minimum delay between process restarts (and
606 // also for timing service stop before the SIGKILL hammer is used).
607 class process_restart_timer : public eventloop_t::timer_impl<process_restart_timer>
608 {
609     public:
610     base_process_service * service;
611
612     process_restart_timer()
613     {
614     }
615
616     rearm timer_expiry(eventloop_t &, int expiry_count);
617 };
618
619 class base_process_service : public service_record
620 {
621     friend class service_child_watcher;
622     friend class exec_status_pipe_watcher;
623     friend class process_restart_timer;
624
625     private:
626     // Re-launch process
627     void do_restart() noexcept;
628
629     protected:
630     service_child_watcher child_listener;
631     exec_status_pipe_watcher child_status_listener;
632     process_restart_timer restart_timer;
633     time_val last_start_time;
634
635     // Restart interval time and restart count are used to track the number of automatic restarts
636     // over an interval. Too many restarts over an interval will inhibit further restarts.
637     time_val restart_interval_time;
638     int restart_interval_count;
639
640     time_val restart_interval;
641     int max_restart_interval_count;
642     time_val restart_delay;
643
644     // Time allowed for service stop, after which SIGKILL is sent. 0 to disable.
645     time_val stop_timeout = {10, 0}; // default of 10 seconds
646
647     bool waiting_restart_timer : 1;
648     bool stop_timer_armed : 1;
649     bool reserved_child_watch : 1;
650     bool tracking_child : 1;  // whether we expect to see child process status
651     bool start_is_interruptible : 1;  // whether we can interrupt start
652
653     // Start the process, return true on success
654     virtual bool start_ps_process() noexcept override;
655     bool start_ps_process(const std::vector<const char *> &args, bool on_console) noexcept;
656
657     // Restart the process (due to start failure or unexpected termination). Restarts will be
658     // rate-limited.
659     bool restart_ps_process() noexcept;
660
661     // Perform smooth recovery process
662     void do_smooth_recovery() noexcept;
663
664     virtual void bring_down() noexcept override;
665
666     // Called when the process exits. The exit_status is the status value yielded by
667     // the "wait" system call.
668     virtual void handle_exit_status(int exit_status) noexcept = 0;
669     virtual void exec_failed(int errcode) noexcept = 0;
670
671     virtual bool can_interrupt_start() noexcept override
672     {
673         return waiting_restart_timer || service_record::can_interrupt_start();
674     }
675
676     virtual bool can_proceed_to_start() noexcept override
677     {
678         return ! waiting_restart_timer;
679     }
680
681     virtual void interrupt_start() noexcept override;
682
683     // Kill with SIGKILL
684     void kill_with_fire() noexcept;
685
686     // Signal the process group of the service process
687     void kill_pg(int signo) noexcept;
688
689     public:
690     base_process_service(service_set *sset, string name, service_type record_type_p, string &&command,
691             std::list<std::pair<unsigned,unsigned>> &command_offsets,
692             const std::list<prelim_dep> &deplist_p);
693
694     ~base_process_service() noexcept
695     {
696     }
697
698     void set_restart_interval(timespec interval, int max_restarts) noexcept
699     {
700         restart_interval = interval;
701         max_restart_interval_count = max_restarts;
702     }
703
704     void set_restart_delay(timespec delay) noexcept
705     {
706         restart_delay = delay;
707     }
708
709     void set_stop_timeout(timespec timeout) noexcept
710     {
711         stop_timeout = timeout;
712     }
713 };
714
715 class process_service : public base_process_service
716 {
717     virtual void handle_exit_status(int exit_status) noexcept override;
718     virtual void exec_failed(int errcode) noexcept override;
719     virtual void bring_down() noexcept override;
720
721     public:
722     process_service(service_set *sset, string name, string &&command,
723             std::list<std::pair<unsigned,unsigned>> &command_offsets,
724             std::list<prelim_dep> depends_p)
725          : base_process_service(sset, name, service_type::PROCESS, std::move(command), command_offsets,
726              depends_p)
727     {
728     }
729
730     ~process_service() noexcept
731     {
732     }
733 };
734
735 class bgproc_service : public base_process_service
736 {
737     virtual void handle_exit_status(int exit_status) noexcept override;
738     virtual void exec_failed(int errcode) noexcept override;
739
740     enum class pid_result_t {
741         OK,
742         FAILED,      // failed to read pid or read invalid pid
743         TERMINATED   // read pid successfully, but the process already terminated
744     };
745
746     // Read the pid-file, return false on failure
747     pid_result_t read_pid_file(int *exit_status) noexcept;
748
749     public:
750     bgproc_service(service_set *sset, string name, string &&command,
751             std::list<std::pair<unsigned,unsigned>> &command_offsets,
752             std::list<prelim_dep> depends_p)
753          : base_process_service(sset, name, service_type::BGPROCESS, std::move(command), command_offsets,
754              depends_p)
755     {
756     }
757
758     ~bgproc_service() noexcept
759     {
760     }
761 };
762
763 class scripted_service : public base_process_service
764 {
765     virtual void handle_exit_status(int exit_status) noexcept override;
766     virtual void exec_failed(int errcode) noexcept override;
767     virtual void bring_down() noexcept override;
768
769     public:
770     scripted_service(service_set *sset, string name, string &&command,
771             std::list<std::pair<unsigned,unsigned>> &command_offsets,
772             std::list<prelim_dep> depends_p)
773          : base_process_service(sset, name, service_type::SCRIPTED, std::move(command), command_offsets,
774              depends_p)
775     {
776     }
777
778     ~scripted_service() noexcept
779     {
780     }
781 };
782
783 inline auto extract_prop_queue(service_record *sr) -> decltype(sr->prop_queue_node) &
784 {
785     return sr->prop_queue_node;
786 }
787
788 inline auto extract_stop_queue(service_record *sr) -> decltype(sr->stop_queue_node) &
789 {
790     return sr->stop_queue_node;
791 }
792
793 inline auto extract_console_queue(service_record *sr) -> decltype(sr->console_queue_node) &
794 {
795     return sr->console_queue_node;
796 }
797
798 /*
799  * A service_set, as the name suggests, manages a set of services.
800  *
801  * Other than the ability to find services by name, the service set manages various queues.
802  * One is the queue for processes wishing to acquire the console. There is also a set of
803  * processes that want to start, and another set of those that want to stop. These latter
804  * two "queues" (not really queues since their order is not important) are used to prevent too
805  * much recursion and to prevent service states from "bouncing" too rapidly.
806  * 
807  * A service that wishes to start or stop puts itself on the start/stop queue; a service that
808  * needs to propagate changes to dependent services or dependencies puts itself on the
809  * propagation queue. Any operation that potentially manipulates the queues must be followed
810  * by a "process queues" order (processQueues() method).
811  *
812  * Note that processQueues always repeatedly processes both queues until they are empty. The
813  * process is finite because starting a service can never cause services to stop, unless they
814  * fail to start, which should cause them to stop semi-permanently.
815  */
816 class service_set
817 {
818     protected:
819     int active_services;
820     std::list<service_record *> records;
821     bool restart_enabled; // whether automatic restart is enabled (allowed)
822     
823     shutdown_type_t shutdown_type = shutdown_type_t::CONTINUE;  // Shutdown type, if stopping
824     
825     // Services waiting for exclusive access to the console
826     dlist<service_record, extract_console_queue> console_queue;
827
828     // Propagation and start/stop "queues" - list of services waiting for processing
829     slist<service_record, extract_prop_queue> prop_queue;
830     slist<service_record, extract_stop_queue> stop_queue;
831     
832     public:
833     service_set()
834     {
835         active_services = 0;
836         restart_enabled = true;
837     }
838     
839     virtual ~service_set()
840     {
841         for (auto * s : records) {
842             delete s;
843         }
844     }
845
846     // Start the specified service. The service will be marked active.
847     void start_service(service_record *svc)
848     {
849         svc->start();
850         process_queues();
851     }
852
853     // Stop the specified service. Its active mark will be cleared.
854     void stop_service(service_record *svc)
855     {
856         svc->stop(true);
857         process_queues();
858     }
859
860     // Locate an existing service record.
861     service_record *find_service(const std::string &name) noexcept;
862
863     // Load a service description, and dependencies, if there is no existing
864     // record for the given name.
865     // Throws:
866     //   ServiceLoadException (or subclass) on problem with service description
867     //   std::bad_alloc on out-of-memory condition
868     virtual service_record *load_service(const char *name)
869     {
870         auto r = find_service(name);
871         if (r == nullptr) {
872             throw service_not_found(name);
873         }
874         return r;
875     }
876
877     // Start the service with the given name. The named service will begin
878     // transition to the 'started' state.
879     //
880     // Throws a ServiceLoadException (or subclass) if the service description
881     // cannot be loaded or is invalid;
882     // Throws std::bad_alloc if out of memory.
883     void start_service(const char *name)
884     {
885         using namespace std;
886         service_record *record = load_service(name);
887         service_set::start_service(record);
888     }
889     
890     void add_service(service_record *svc)
891     {
892         records.push_back(svc);
893     }
894     
895     void remove_service(service_record *svc)
896     {
897         std::remove(records.begin(), records.end(), svc);
898     }
899
900     // Get the list of all loaded services.
901     const std::list<service_record *> &list_services() noexcept
902     {
903         return records;
904     }
905     
906     // Stop the service with the given name. The named service will begin
907     // transition to the 'stopped' state.
908     void stop_service(const std::string &name) noexcept;
909     
910     // Add a service record to the state propagation queue. The service record will have its
911     // do_propagation() method called when the queue is processed.
912     void add_prop_queue(service_record *service) noexcept
913     {
914         if (! prop_queue.is_queued(service)) {
915             prop_queue.insert(service);
916         }
917     }
918     
919     // Add a service record to the stop queue. The service record will have its
920     // execute_transition() method called when the queue is processed.
921     void add_transition_queue(service_record *service) noexcept
922     {
923         if (! stop_queue.is_queued(service)) {
924             stop_queue.insert(service);
925         }
926     }
927     
928     // Process state propagation and start/stop queues, until they are empty.
929     void process_queues() noexcept
930     {
931         while (! stop_queue.is_empty() || ! prop_queue.is_empty()) {
932             while (! prop_queue.is_empty()) {
933                 auto next = prop_queue.pop_front();
934                 next->do_propagation();
935             }
936             while (! stop_queue.is_empty()) {
937                 auto next = stop_queue.pop_front();
938                 next->execute_transition();
939             }
940         }
941     }
942     
943     // Set the console queue tail (returns previous tail)
944     void append_console_queue(service_record * newTail) noexcept
945     {
946         bool was_empty = console_queue.is_empty();
947         console_queue.append(newTail);
948         if (was_empty) {
949             enable_console_log(false);
950         }
951     }
952     
953     // Pull and dispatch a waiter from the console queue
954     void pull_console_queue() noexcept
955     {
956         if (console_queue.is_empty()) {
957             enable_console_log(true);
958         }
959         else {
960             service_record * front = console_queue.pop_front();
961             front->acquired_console();
962         }
963     }
964     
965     void unqueue_console(service_record * service) noexcept
966     {
967         if (console_queue.is_queued(service)) {
968             console_queue.unlink(service);
969         }
970     }
971
972     // Notification from service that it is active (state != STOPPED)
973     // Only to be called on the transition from inactive to active.
974     void service_active(service_record *) noexcept;
975     
976     // Notification from service that it is inactive (STOPPED)
977     // Only to be called on the transition from active to inactive.
978     void service_inactive(service_record *) noexcept;
979     
980     // Find out how many services are active (starting, running or stopping,
981     // but not stopped).
982     int count_active_services() noexcept
983     {
984         return active_services;
985     }
986     
987     void stop_all_services(shutdown_type_t type = shutdown_type_t::HALT) noexcept
988     {
989         restart_enabled = false;
990         shutdown_type = type;
991         for (std::list<service_record *>::iterator i = records.begin(); i != records.end(); ++i) {
992             (*i)->stop(false);
993             (*i)->unpin();
994         }
995         process_queues();
996     }
997     
998     void set_auto_restart(bool restart) noexcept
999     {
1000         restart_enabled = restart;
1001     }
1002     
1003     bool get_auto_restart() noexcept
1004     {
1005         return restart_enabled;
1006     }
1007     
1008     shutdown_type_t getShutdownType() noexcept
1009     {
1010         return shutdown_type;
1011     }
1012 };
1013
1014 class dirload_service_set : public service_set
1015 {
1016     const char *service_dir;  // directory containing service descriptions
1017
1018     public:
1019     dirload_service_set(const char *service_dir_p) : service_set(), service_dir(service_dir_p)
1020     {
1021     }
1022
1023     service_record *load_service(const char *name) override;
1024 };
1025
1026 #endif