blob: 8c70960a6497ff5b4162826ca6407dac414b157e [file] [log] [blame]
Tyler Chatowa79419d2020-08-12 20:12:11 -07001#ifndef AOS_STARTER_STARTERD_LIB_H_
2#define AOS_STARTER_STARTERD_LIB_H_
3
Tyler Chatowa79419d2020-08-12 20:12:11 -07004#include <sys/signalfd.h>
5#include <sys/wait.h>
6
Tyler Chatowbf0609c2021-07-31 16:13:27 -07007#include <csignal>
8#include <cstdio>
Tyler Chatowa79419d2020-08-12 20:12:11 -07009#include <string>
10#include <unordered_map>
11#include <vector>
12
13#include "aos/configuration.h"
14#include "aos/events/shm_event_loop.h"
15#include "aos/ipc_lib/signalfd.h"
16#include "aos/macros.h"
17#include "aos/starter/starter_generated.h"
18#include "aos/starter/starter_rpc_generated.h"
19
20namespace aos {
21namespace starter {
22
23// RAII Pipe for sending individual ints between reader and writer.
24class ScopedPipe {
25 public:
26 class ScopedReadPipe;
27 class ScopedWritePipe;
28
29 static std::tuple<ScopedReadPipe, ScopedWritePipe> MakePipe();
30
31 virtual ~ScopedPipe();
32
33 int fd() const { return fd_; }
34
35 private:
36 ScopedPipe(int fd = -1);
37
38 int fd_;
39
40 ScopedPipe(const ScopedPipe &) = delete;
41 ScopedPipe &operator=(const ScopedPipe &) = delete;
42 ScopedPipe(ScopedPipe &&);
43 ScopedPipe &operator=(ScopedPipe &&);
44};
45
46class ScopedPipe::ScopedReadPipe : public ScopedPipe {
47 public:
48 std::optional<uint32_t> Read();
49
50 private:
51 using ScopedPipe::ScopedPipe;
52
53 friend class ScopedPipe;
54};
55
56class ScopedPipe::ScopedWritePipe : public ScopedPipe {
57 public:
58 void Write(uint32_t data);
59
60 private:
61 using ScopedPipe::ScopedPipe;
62
63 friend class ScopedPipe;
64};
65
66// Manages a running process, allowing starting and stopping, and restarting
67// automatically.
68class Application {
69 public:
70 Application(const aos::Application *application,
Austin Schuhfc304942021-10-16 14:20:05 -070071 aos::ShmEventLoop *event_loop, std::function<void()> on_change);
Tyler Chatowa79419d2020-08-12 20:12:11 -070072
73 flatbuffers::Offset<aos::starter::ApplicationStatus> PopulateStatus(
74 flatbuffers::FlatBufferBuilder *builder);
75
76 // Returns the last pid of this process. -1 if not started yet.
77 pid_t get_pid() const { return pid_; }
78
79 // Handles a SIGCHLD signal received by the parent. Does nothing if this
80 // process was not the target. Returns true if this Application should be
81 // removed.
82 bool MaybeHandleSignal();
83
84 // Handles a command. May do nothing if application is already in the desired
85 // state.
86 void HandleCommand(aos::starter::Command cmd);
87
88 void Start() { HandleCommand(aos::starter::Command::START); }
89
90 void Stop() { HandleCommand(aos::starter::Command::STOP); }
91
92 void Terminate();
93
94 void set_args(
95 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>
96 &args);
97
Austin Schuh5f79a5a2021-10-12 17:46:50 -070098 bool autostart() const { return autostart_; }
99
Tyler Chatowa79419d2020-08-12 20:12:11 -0700100 private:
101 void DoStart();
102
103 void DoStop(bool restart);
104
105 void QueueStart();
106
107 // Copy flatbuffer vector of strings to vector of std::string.
108 static std::vector<std::string> FbsVectorToVector(
109 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> &v);
110
111 static std::optional<uid_t> FindUid(const char *name);
Austin Schuh529ac592021-10-14 16:11:13 -0700112 static std::optional<gid_t> FindPrimaryGidForUser(const char *name);
Tyler Chatowa79419d2020-08-12 20:12:11 -0700113
114 // Next unique id for all applications
115 static inline uint64_t next_id_ = 0;
116
117 std::string name_;
118 std::string path_;
119 std::vector<char *> args_;
James Kuszmaul4ff50272022-01-07 18:31:13 -0800120 std::string user_name_;
Tyler Chatowa79419d2020-08-12 20:12:11 -0700121 std::optional<uid_t> user_;
Austin Schuh529ac592021-10-14 16:11:13 -0700122 std::optional<gid_t> group_;
Tyler Chatowa79419d2020-08-12 20:12:11 -0700123
124 pid_t pid_ = -1;
125 ScopedPipe::ScopedReadPipe read_pipe_;
126 ScopedPipe::ScopedWritePipe write_pipe_;
127 uint64_t id_;
128 int exit_code_ = 0;
129 aos::monotonic_clock::time_point start_time_, exit_time_;
130 bool queue_restart_ = false;
131 bool terminating_ = false;
Austin Schuh5f79a5a2021-10-12 17:46:50 -0700132 bool autostart_ = true;
Tyler Chatowa79419d2020-08-12 20:12:11 -0700133
134 aos::starter::State status_ = aos::starter::State::STOPPED;
135 aos::starter::LastStopReason stop_reason_ =
136 aos::starter::LastStopReason::STOP_REQUESTED;
137
138 aos::ShmEventLoop *event_loop_;
139 aos::TimerHandler *start_timer_, *restart_timer_, *stop_timer_;
140
Austin Schuhfc304942021-10-16 14:20:05 -0700141 std::function<void()> on_change_;
142
Tyler Chatowa79419d2020-08-12 20:12:11 -0700143 DISALLOW_COPY_AND_ASSIGN(Application);
144};
145
146// Registers a signalfd listener with the given event loop and calls callback
147// whenever a signal is received.
148class SignalListener {
149 public:
150 SignalListener(aos::ShmEventLoop *loop,
151 std::function<void(signalfd_siginfo)> callback);
152
153 ~SignalListener();
154
155 private:
156 aos::ShmEventLoop *loop_;
157 std::function<void(signalfd_siginfo)> callback_;
158 aos::ipc_lib::SignalFd signalfd_;
159
160 DISALLOW_COPY_AND_ASSIGN(SignalListener);
161};
162
James Kuszmaul293b2172021-11-10 16:20:48 -0800163const aos::Channel *StatusChannelForNode(const aos::Configuration *config,
164 const aos::Node *node);
165const aos::Channel *StarterRpcChannelForNode(const aos::Configuration *config,
166 const aos::Node *node);
167
Tyler Chatowa79419d2020-08-12 20:12:11 -0700168class Starter {
169 public:
170 Starter(const aos::Configuration *event_loop_config);
171
172 // Inserts a new application from config. Returns the inserted application if
173 // it was successful, otherwise nullptr if an application already exists
174 // with the given name.
175 Application *AddApplication(const aos::Application *application);
176
177 // Runs the event loop and starts all applications
178 void Run();
179
180 void Cleanup();
181
182 private:
183 // Signals which indicate starter has died
184 static const inline std::vector<int> kStarterDeath = {
185 SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGFPE,
186 SIGSEGV, SIGPIPE, SIGTERM, SIGBUS, SIGXCPU};
187
188 void OnSignal(signalfd_siginfo signal);
James Kuszmaul293b2172021-11-10 16:20:48 -0800189 void HandleStarterRpc(const StarterRpc &command);
Tyler Chatowa79419d2020-08-12 20:12:11 -0700190
Austin Schuhfc304942021-10-16 14:20:05 -0700191 // Sends the Status message if it wouldn't exceed the rate limit.
192 void MaybeSendStatus();
193
Tyler Chatowa79419d2020-08-12 20:12:11 -0700194 void SendStatus();
195
196 const std::string config_path_;
197 const aos::Configuration *config_msg_;
198
199 aos::ShmEventLoop event_loop_;
200 aos::Sender<aos::starter::Status> status_sender_;
201 aos::TimerHandler *status_timer_;
202 aos::TimerHandler *cleanup_timer_;
203
Austin Schuhfc304942021-10-16 14:20:05 -0700204 int status_count_ = 0;
205 const int max_status_count_;
206
Tyler Chatowa79419d2020-08-12 20:12:11 -0700207 std::unordered_map<std::string, Application> applications_;
208
209 // Set to true on cleanup to block rpc commands and ensure cleanup only
210 // happens once.
211 bool exiting_ = false;
212
213 SignalListener listener_;
214
215 DISALLOW_COPY_AND_ASSIGN(Starter);
216};
217
218} // namespace starter
219} // namespace aos
220
221#endif // AOS_STARTER_STARTERD_LIB_H_