8 #include <unordered_set>
14 #include "service-listener.h"
15 #include "service-constants.h"
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.
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.
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
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.
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.
46 * Acquisition/release:
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).
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).
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).
67 * The priority of the different state deciders is:
70 * - desired state (which is manipulated by require/release operations)
72 * So a forced stop cannot occur until the service is not pinned started, for instance.
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).
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).
85 * Propagation variables:
86 * prop_acquire: the service has transitioned to an acquired state and must issue an acquire
88 * prop_release: the service has transitioned to a released state and must issue a release on
91 * prop_start: the service should start
92 * prop_stop: the service should stop
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.
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.
105 struct onstart_flags_t {
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
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)
121 // Exception while loading a service
122 class service_load_exc
125 std::string serviceName;
126 std::string excDescription;
129 service_load_exc(std::string serviceName, std::string &&desc) noexcept
130 : serviceName(serviceName), excDescription(std::move(desc))
135 class service_not_found : public service_load_exc
138 service_not_found(std::string serviceName) noexcept
139 : service_load_exc(serviceName, "Service description not found.")
144 class service_cyclic_dependency : public service_load_exc
147 service_cyclic_dependency(std::string serviceName) noexcept
148 : service_load_exc(serviceName, "Has cyclic dependency.")
153 class service_description_exc : public service_load_exc
156 service_description_exc(std::string serviceName, std::string &&extraInfo) noexcept
157 : service_load_exc(serviceName, std::move(extraInfo))
162 class service_record;
164 class base_process_service;
166 enum class dependency_type
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
174 /* Service dependency record */
177 service_record * from;
181 /* Whether the 'from' service is waiting for the 'to' service to start */
183 /* Whether the 'from' service is holding an acquire on the 'to' service */
186 const dependency_type dep_type;
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)
192 service_record * get_from() noexcept
197 service_record * get_to() noexcept
203 /* preliminary service dependency information */
207 service_record * const to;
208 dependency_type const dep_type;
210 prelim_dep(service_record *to_p, dependency_type dep_type_p) : to(to_p), dep_type(dep_type_p)
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)
221 std::vector<const char *> r;
222 r.reserve(arg_indices.size() + 1);
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;
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);
236 r.push_back(nullptr);
240 class service_child_watcher : public eventloop_t::child_proc_watcher_impl<service_child_watcher>
243 base_process_service * service;
244 rearm status_change(eventloop_t &eloop, pid_t child, int status) noexcept;
246 service_child_watcher(base_process_service * sr) noexcept : service(sr) { }
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>
253 base_process_service * service;
254 rearm fd_event(eventloop_t &eloop, int fd, int flags) noexcept;
256 exec_status_pipe_watcher(base_process_service * sr) noexcept : service(sr) { }
259 // service_record: base class for service record containing static information
260 // and current state of each service.
264 typedef std::string string;
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 */
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
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
279 onstart_flags_t onstart_flags;
281 string logfile; // log file name, empty string specifies /dev/null
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
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 bool waiting_for_execstat : 1; // if we are waiting for exec status after fork()
290 bool start_explicit : 1; // whether we are are explictly required to be started
292 bool prop_require : 1; // require must be propagated
293 bool prop_release : 1; // release must be propagated
294 bool prop_failure : 1; // failure to start must be propagated
297 bool restarting : 1; // re-starting after unexpected termination
299 int required_by = 0; // number of dependents wanting this service to be started
301 typedef std::list<service_record *> sr_list;
302 typedef sr_list::iterator sr_iter;
304 // list of soft dependencies
305 typedef std::list<service_dep> dep_list;
307 // list of soft dependents
308 typedef std::list<service_dep *> dpt_list;
310 dep_list depends_on; // services this one depends on
311 dpt_list dependents; // services depending on this one
313 service_set *services; // the set this service belongs to
315 std::unordered_set<service_listener *> listeners;
318 bool force_stop; // true if the service must actually stop. This is the
319 // case if for example the process dies; the service,
320 // and all its dependencies, MUST be stopped.
322 int term_signal = -1; // signal to use for process termination
324 string socket_path; // path to the socket for socket-activation service
325 int socket_perms; // socket permissions ("mode")
326 uid_t socket_uid = -1; // socket user id or -1
327 gid_t socket_gid = -1; // socket group id or -1
329 // Implementation details
331 pid_t pid = -1; // PID of the process. If state is STARTING or STOPPING,
332 // this is PID of the service script; otherwise it is the
333 // PID of the process itself (process service).
334 int exit_status; // Exit status, if the process has exited (pid == -1).
335 int socket_fd = -1; // For socket-activation services, this is the file
336 // descriptor for the socket.
338 // Data for use by service_set
342 lld_node<service_record> console_queue_node;
344 // Propagation and start/stop queues
345 lls_node<service_record> prop_queue_node;
346 lls_node<service_record> stop_queue_node;
351 void emergency_stop() noexcept;
353 // All dependents have stopped.
354 virtual void all_deps_stopped() noexcept;
356 // Service has actually stopped (includes having all dependents
357 // reaching STOPPED state).
358 void stopped() noexcept;
360 // Service has successfully started
361 void started() noexcept;
363 // Service failed to start (only called when in STARTING state).
364 // dep_failed: whether failure is recorded due to a dependency failing
365 void failed_to_start(bool dep_failed = false) noexcept;
367 void run_child_proc(const char * const *args, const char *logfile, bool on_console, int wpipefd,
370 // A dependency has reached STARTED state
371 void dependencyStarted() noexcept;
373 void all_deps_started(bool haveConsole = false) noexcept;
375 // Do any post-dependency startup; return false on failure
376 virtual bool start_ps_process() noexcept;
378 // Open the activation socket, return false on failure
379 bool open_socket() noexcept;
381 // Start all dependencies, return true if all have started
382 bool start_check_dependencies() noexcept;
384 // Check whether all dependencies have started (i.e. whether we can start now)
385 bool check_deps_started() noexcept;
387 // Whether a STARTING service can immediately transition to STOPPED (as opposed to
388 // having to wait for it reach STARTED and then go through STOPPING).
389 virtual bool can_interrupt_start() noexcept
391 return waiting_for_deps;
394 virtual void interrupt_start() noexcept;
396 // Whether a STOPPING service can immediately transition to STARTED.
397 bool can_interrupt_stop() noexcept
399 return waiting_for_deps && ! force_stop;
402 // A dependent has reached STOPPED state
403 void dependent_stopped() noexcept;
405 // check if all dependents have stopped
406 bool stop_check_dependents() noexcept;
408 // issue a stop to all dependents, return true if they are all already stopped
409 bool stop_dependents() noexcept;
411 void require() noexcept;
412 void release() noexcept;
413 void release_dependencies() noexcept;
415 // Check if service is, fundamentally, stopped.
416 bool is_stopped() noexcept
418 return service_state == service_state_t::STOPPED
419 || (service_state == service_state_t::STARTING && waiting_for_deps);
422 void notify_listeners(service_event event) noexcept
424 for (auto l : listeners) {
425 l->serviceEvent(this, event);
429 // Queue to run on the console. 'acquired_console()' will be called when the console is available.
430 // Has no effect if the service has already queued for console.
431 void queue_for_console() noexcept;
433 // Release console (console must be currently held by this service)
434 void release_console() noexcept;
436 bool do_auto_restart() noexcept;
438 // Started state reached
439 bool process_started() noexcept;
443 service_record(service_set *set, string name)
444 : service_state(service_state_t::STOPPED), desired_state(service_state_t::STOPPED),
445 auto_restart(false), smooth_recovery(false),
446 pinned_stopped(false), pinned_started(false), waiting_for_deps(false),
447 waiting_for_execstat(false), start_explicit(false),
448 prop_require(false), prop_release(false), prop_failure(false),
449 prop_start(false), prop_stop(false), restarting(false), force_stop(false)
453 record_type = service_type::DUMMY;
458 service_record(service_set *set, string name, service_type record_type_p,
459 const std::list<prelim_dep> &deplist_p)
460 : service_record(set, name)
464 this->record_type = record_type_p;
466 for (auto & pdep : deplist_p) {
467 auto b = depends_on.emplace(depends_on.end(), this, pdep.to, pdep.dep_type);
468 pdep.to->dependents.push_back(&(*b));
472 service_record(service_set *set, string name, service_type record_type_p, string &&command,
473 std::list<std::pair<unsigned,unsigned>> &command_offsets,
474 const std::list<prelim_dep> &deplist_p)
475 : service_record(set, name, record_type_p, deplist_p)
477 program_name = std::move(command);
478 exec_arg_parts = separate_args(program_name, command_offsets);
481 virtual ~service_record() noexcept
485 // begin transition from stopped to started state or vice versa depending on current and desired state
486 void execute_transition() noexcept;
488 void do_propagation() noexcept;
490 // Called on transition of desired state from stopped to started (or unpinned stop)
491 void do_start() noexcept;
493 // Called on transition of desired state from started to stopped (or unpinned start)
494 void do_stop() noexcept;
496 // Console is available.
497 void acquired_console() noexcept;
499 // Set the stop command and arguments (may throw std::bad_alloc)
500 void set_stop_command(std::string command, std::list<std::pair<unsigned,unsigned>> &stop_command_offsets)
502 stop_command = command;
503 stop_arg_parts = separate_args(stop_command, stop_command_offsets);
506 // Get the target (aka desired) state.
507 service_state_t get_target_state() noexcept
509 return desired_state;
512 // Set logfile, should be done before service is started
513 void set_log_file(string logfile)
515 this->logfile = logfile;
518 // Set whether this service should automatically restart when it dies
519 void set_auto_restart(bool auto_restart) noexcept
521 this->auto_restart = auto_restart;
524 void set_smooth_recovery(bool smooth_recovery) noexcept
526 this->smooth_recovery = smooth_recovery;
529 // Set "on start" flags (commands)
530 void set_flags(onstart_flags_t flags) noexcept
532 this->onstart_flags = flags;
535 // Set an additional signal (other than SIGTERM) to be used to terminate the process
536 void set_extra_termination_signal(int signo) noexcept
538 this->term_signal = signo;
541 void set_pid_file(string &&pid_file) noexcept
543 this->pid_file = std::move(pid_file);
546 void set_socket_details(string &&socket_path, int socket_perms, uid_t socket_uid, uid_t socket_gid) noexcept
548 this->socket_path = std::move(socket_path);
549 this->socket_perms = socket_perms;
550 this->socket_uid = socket_uid;
551 this->socket_gid = socket_gid;
554 const std::string &get_service_name() const noexcept { return service_name; }
555 service_state_t get_state() const noexcept { return service_state; }
557 void start(bool activate = true) noexcept; // start the service
558 void stop(bool bring_down = true) noexcept; // stop the service
560 void forced_stop() noexcept; // force-stop this service and all dependents
562 // Pin the service in "started" state (when it reaches the state)
563 void pin_start() noexcept
565 pinned_started = true;
568 // Pin the service in "stopped" state (when it reaches the state)
569 void pin_stop() noexcept
571 pinned_stopped = true;
574 // Remove both "started" and "stopped" pins. If the service is currently pinned
575 // in either state but would naturally be in the opposite state, it will immediately
576 // commence starting/stopping.
577 void unpin() noexcept;
579 bool isDummy() noexcept
581 return record_type == service_type::DUMMY;
584 // Add a listener. A listener must only be added once. May throw std::bad_alloc.
585 void addListener(service_listener * listener)
587 listeners.insert(listener);
590 // Remove a listener.
591 void removeListener(service_listener * listener) noexcept
593 listeners.erase(listener);
597 class base_process_service;
599 // A timer for process restarting. Used to ensure a minimum delay between process restarts (and
600 // also for timing service stop before the SIGKILL hammer is used).
601 class process_restart_timer : public eventloop_t::timer_impl<process_restart_timer>
604 base_process_service * service;
606 process_restart_timer()
610 rearm timer_expiry(eventloop_t &, int expiry_count);
613 class base_process_service : public service_record
615 friend class service_child_watcher;
616 friend class exec_status_pipe_watcher;
617 friend class process_restart_timer;
621 void do_restart() noexcept;
624 service_child_watcher child_listener;
625 exec_status_pipe_watcher child_status_listener;
626 process_restart_timer restart_timer;
627 time_val last_start_time;
629 // Restart interval time and restart count are used to track the number of automatic restarts
630 // over an interval. Too many restarts over an interval will inhibit further restarts.
631 time_val restart_interval_time;
632 int restart_interval_count;
634 time_val restart_interval;
635 int max_restart_interval_count;
636 time_val restart_delay;
638 // Time allowed for service stop, after which SIGKILL is sent. 0 to disable.
639 time_val stop_timeout = {10, 0}; // default of 10 seconds
641 bool waiting_restart_timer : 1;
642 bool stop_timer_armed : 1;
643 bool reserved_child_watch : 1;
644 bool tracking_child : 1;
646 // Start the process, return true on success
647 virtual bool start_ps_process() noexcept override;
648 bool start_ps_process(const std::vector<const char *> &args, bool on_console) noexcept;
650 // Restart the process (due to start failure or unexpected termination). Restarts will be
652 bool restart_ps_process() noexcept;
654 // Perform smooth recovery process
655 void do_smooth_recovery() noexcept;
657 virtual void all_deps_stopped() noexcept override;
658 virtual void handle_exit_status(int exit_status) noexcept = 0;
660 virtual bool can_interrupt_start() noexcept override
662 return waiting_restart_timer || service_record::can_interrupt_start();
665 virtual void interrupt_start() noexcept override;
668 void kill_with_fire() noexcept;
670 // Signal the process group of the service process
671 void kill_pg(int signo) noexcept;
674 base_process_service(service_set *sset, string name, service_type record_type_p, string &&command,
675 std::list<std::pair<unsigned,unsigned>> &command_offsets,
676 const std::list<prelim_dep> &deplist_p);
678 ~base_process_service() noexcept
682 void set_restart_interval(timespec interval, int max_restarts) noexcept
684 restart_interval = interval;
685 max_restart_interval_count = max_restarts;
688 void set_restart_delay(timespec delay) noexcept
690 restart_delay = delay;
693 void set_stop_timeout(timespec timeout) noexcept
695 stop_timeout = timeout;
699 class process_service : public base_process_service
701 // called when the process exits. The exit_status is the status value yielded by
702 // the "wait" system call.
703 virtual void handle_exit_status(int exit_status) noexcept override;
706 process_service(service_set *sset, string name, string &&command,
707 std::list<std::pair<unsigned,unsigned>> &command_offsets,
708 std::list<prelim_dep> depends_p)
709 : base_process_service(sset, name, service_type::PROCESS, std::move(command), command_offsets,
714 ~process_service() noexcept
719 class bgproc_service : public base_process_service
721 virtual void handle_exit_status(int exit_status) noexcept override;
723 enum class pid_result_t {
725 FAILED, // failed to read pid or read invalid pid
726 TERMINATED // read pid successfully, but the process already terminated
729 // Read the pid-file, return false on failure
730 pid_result_t read_pid_file(int *exit_status) noexcept;
733 bgproc_service(service_set *sset, string name, string &&command,
734 std::list<std::pair<unsigned,unsigned>> &command_offsets,
735 std::list<prelim_dep> depends_p)
736 : base_process_service(sset, name, service_type::BGPROCESS, std::move(command), command_offsets,
739 tracking_child = false;
740 reserved_child_watch = false;
743 ~bgproc_service() noexcept
748 class scripted_service : public base_process_service
750 virtual void all_deps_stopped() noexcept override;
751 virtual void handle_exit_status(int exit_status) noexcept override;
754 scripted_service(service_set *sset, string name, string &&command,
755 std::list<std::pair<unsigned,unsigned>> &command_offsets,
756 std::list<prelim_dep> depends_p)
757 : base_process_service(sset, name, service_type::SCRIPTED, std::move(command), command_offsets,
762 ~scripted_service() noexcept
767 inline auto extract_prop_queue(service_record *sr) -> decltype(sr->prop_queue_node) &
769 return sr->prop_queue_node;
772 inline auto extract_stop_queue(service_record *sr) -> decltype(sr->stop_queue_node) &
774 return sr->stop_queue_node;
777 inline auto extract_console_queue(service_record *sr) -> decltype(sr->console_queue_node) &
779 return sr->console_queue_node;
783 * A service_set, as the name suggests, manages a set of services.
785 * Other than the ability to find services by name, the service set manages various queues.
786 * One is the queue for processes wishing to acquire the console. There is also a set of
787 * processes that want to start, and another set of those that want to stop. These latter
788 * two "queues" (not really queues since their order is not important) are used to prevent too
789 * much recursion and to prevent service states from "bouncing" too rapidly.
791 * A service that wishes to start or stop puts itself on the start/stop queue; a service that
792 * needs to propagate changes to dependent services or dependencies puts itself on the
793 * propagation queue. Any operation that potentially manipulates the queues must be followed
794 * by a "process queues" order (processQueues() method).
796 * Note that processQueues always repeatedly processes both queues until they are empty. The
797 * process is finite because starting a service can never cause services to stop, unless they
798 * fail to start, which should cause them to stop semi-permanently.
804 std::list<service_record *> records;
805 bool restart_enabled; // whether automatic restart is enabled (allowed)
807 shutdown_type_t shutdown_type = shutdown_type_t::CONTINUE; // Shutdown type, if stopping
809 // Services waiting for exclusive access to the console
810 dlist<service_record, extract_console_queue> console_queue;
812 // Propagation and start/stop "queues" - list of services waiting for processing
813 slist<service_record, extract_prop_queue> prop_queue;
814 slist<service_record, extract_stop_queue> stop_queue;
820 restart_enabled = true;
823 virtual ~service_set()
825 for (auto * s : records) {
830 // Start the specified service. The service will be marked active.
831 void start_service(service_record *svc)
837 // Stop the specified service. Its active mark will be cleared.
838 void stop_service(service_record *svc)
844 // Locate an existing service record.
845 service_record *find_service(const std::string &name) noexcept;
847 // Load a service description, and dependencies, if there is no existing
848 // record for the given name.
850 // ServiceLoadException (or subclass) on problem with service description
851 // std::bad_alloc on out-of-memory condition
852 virtual service_record *load_service(const char *name)
854 auto r = find_service(name);
856 throw service_not_found(name);
861 // Start the service with the given name. The named service will begin
862 // transition to the 'started' state.
864 // Throws a ServiceLoadException (or subclass) if the service description
865 // cannot be loaded or is invalid;
866 // Throws std::bad_alloc if out of memory.
867 void start_service(const char *name)
870 service_record *record = load_service(name);
871 service_set::start_service(record);
874 void add_service(service_record *svc)
876 records.push_back(svc);
879 void remove_service(service_record *svc)
881 std::remove(records.begin(), records.end(), svc);
884 // Get the list of all loaded services.
885 const std::list<service_record *> &listServices()
890 // Stop the service with the given name. The named service will begin
891 // transition to the 'stopped' state.
892 void stop_service(const std::string &name) noexcept;
894 // Add a service record to the state propagation queue. The service record will have its
895 // do_propagation() method called when the queue is processed.
896 void add_prop_queue(service_record *service) noexcept
898 if (! prop_queue.is_queued(service)) {
899 prop_queue.insert(service);
903 // Add a service record to the stop queue. The service record will have its
904 // execute_transition() method called when the queue is processed.
905 void add_transition_queue(service_record *service) noexcept
907 if (! stop_queue.is_queued(service)) {
908 stop_queue.insert(service);
912 // Process state propagation and start/stop queues, until they are empty.
913 void process_queues() noexcept
915 while (! stop_queue.is_empty() || ! prop_queue.is_empty()) {
916 while (! prop_queue.is_empty()) {
917 auto next = prop_queue.pop_front();
918 next->do_propagation();
920 while (! stop_queue.is_empty()) {
921 auto next = stop_queue.pop_front();
922 next->execute_transition();
927 // Set the console queue tail (returns previous tail)
928 void append_console_queue(service_record * newTail) noexcept
930 bool was_empty = console_queue.is_empty();
931 console_queue.append(newTail);
933 enable_console_log(false);
937 // Pull and dispatch a waiter from the console queue
938 void pull_console_queue() noexcept
940 if (console_queue.is_empty()) {
941 enable_console_log(true);
944 service_record * front = console_queue.pop_front();
945 front->acquired_console();
949 void unqueue_console(service_record * service) noexcept
951 if (console_queue.is_queued(service)) {
952 console_queue.unlink(service);
956 // Notification from service that it is active (state != STOPPED)
957 // Only to be called on the transition from inactive to active.
958 void service_active(service_record *) noexcept;
960 // Notification from service that it is inactive (STOPPED)
961 // Only to be called on the transition from active to inactive.
962 void service_inactive(service_record *) noexcept;
964 // Find out how many services are active (starting, running or stopping,
966 int count_active_services() noexcept
968 return active_services;
971 void stop_all_services(shutdown_type_t type = shutdown_type_t::HALT) noexcept
973 restart_enabled = false;
974 shutdown_type = type;
975 for (std::list<service_record *>::iterator i = records.begin(); i != records.end(); ++i) {
982 void set_auto_restart(bool restart) noexcept
984 restart_enabled = restart;
987 bool get_auto_restart() noexcept
989 return restart_enabled;
992 shutdown_type_t getShutdownType() noexcept
994 return shutdown_type;
998 class dirload_service_set : public service_set
1000 const char *service_dir; // directory containing service descriptions
1003 dirload_service_set(const char *service_dir_p) : service_set(), service_dir(service_dir_p)
1007 service_record *load_service(const char *name) override;