2479575822

Committed 25 Apr 2026 04:16PM UTC coverage: 81.397% (-0.04%) from 81.433%

Build # 2479575822

Build Type

Pull #1927

gitlab-ci

Committed by

web-flow

Commit Message

chore: bump src/common/vendor/json from `f534f4f` to `98386eb`

Bumps [src/common/vendor/json](https://github.com/nlohmann/json) from `f534f4f` to `98386eb`.
- [Release notes](https://github.com/nlohmann/json/releases)
- [Commits](https://github.com/nlohmann/json/compare/f534f4f75...98386eb08)

---
updated-dependencies:
- dependency-name: src/common/vendor/json
  dependency-version: 9a737481a
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #1927: chore: bump src/common/vendor/json from `f534f4f` to `98386eb`

Coverage Stats

9180 of 11278 relevant lines covered (81.4%)

20238.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.78

/src/common/processes/platform/tiny_process_library/tiny_process_library.cpp

// Copyright 2023 Northern.tech AS
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.

#include <common/processes.hpp>

#include <string>
#include <string_view>

#include <common/events_io.hpp>
#include <common/io.hpp>
#include <common/log.hpp>
#include <common/path.hpp>

using namespace std;

namespace mender {
namespace common {
namespace processes {

const chrono::seconds MAX_TERMINATION_TIME(10);

namespace io = mender::common::io;
namespace log = mender::common::log;
namespace path = mender::common::path;

class ProcessReaderFunctor {
public:
        void operator()(const char *bytes, size_t n);

        // Note: ownership is not held here, but in Process.
        int fd_;

        OutputCallback callback_;
};

Process::Process(const vector<string> &args) :
        args_ {args},
        max_termination_time_ {MAX_TERMINATION_TIME} {
        async_wait_data_ = make_shared<AsyncWaitData>();
}

Process::~Process() {
        {
                unique_lock lock(async_wait_data_->data_mutex);
                // DoCancel() requires being locked.
                DoCancel();
        }

        EnsureTerminated();

        if (stdout_pipe_ >= 0) {
                close(stdout_pipe_);
        }
        if (stderr_pipe_ >= 0) {
                close(stderr_pipe_);
        }
}

error::Error Process::Start(OutputCallback stdout_callback, OutputCallback stderr_callback) {
        if (proc_) {
                return MakeError(ProcessAlreadyStartedError, "Cannot start process");
        }

        // Tiny-process-library doesn't give a good error if the command isn't found (just returns
        // exit code 1). If the path is absolute, it's pretty easy to check if it exists. This won't
        // cover all errors (non-absolute or unset executable bit, for example), but helps a little,
        // at least.
        if (args_.size() > 0 && path::IsAbsolute(args_[0])) {
                ifstream f(args_[0]);
                if (!f.good()) {
                        int errnum = errno;
                        return error::Error(
                                generic_category().default_error_condition(errnum), "Cannot launch " + args_[0]);
                }
        }

        OutputCallback maybe_stdout_callback;
        if (stdout_pipe_ >= 0 || stdout_callback) {
                maybe_stdout_callback = ProcessReaderFunctor {stdout_pipe_, stdout_callback};
        }
        OutputCallback maybe_stderr_callback;
        if (stderr_pipe_ >= 0 || stderr_callback) {
                maybe_stderr_callback = ProcessReaderFunctor {stderr_pipe_, stderr_callback};
        }

        proc_ =
                make_unique<tpl::Process>(args_, work_dir_, maybe_stdout_callback, maybe_stderr_callback);

        if (proc_->get_id() == -1) {
                proc_.reset();
                return MakeError(
                        ProcessesErrorCode::SpawnError,
                        "Failed to spawn '" + (args_.size() >= 1 ? args_[0] : "<null>") + "'");
        }

        SetupAsyncWait();

        return error::NoError;
}

error::Error Process::Run() {
        auto err = Start();
        if (err != error::NoError) {
                log::Error(err.String());
        }
        return Wait();
}

static error::Error ErrorBasedOnExitStatus(int exit_status) {
        if (exit_status != 0) {
                return MakeError(
                        NonZeroExitStatusError, "Process exited with status " + to_string(exit_status));
        } else {
                return error::NoError;
        }
}

error::Error Process::Wait() {
        if (proc_) {
                exit_status_ = future_exit_status_.get();
                proc_.reset();
                if (stdout_pipe_ >= 0) {
                        close(stdout_pipe_);
                        stdout_pipe_ = -1;
                }
                if (stderr_pipe_ >= 0) {
                        close(stderr_pipe_);
                        stderr_pipe_ = -1;
                }
        }
        return ErrorBasedOnExitStatus(exit_status_);
}

error::Error Process::Wait(chrono::nanoseconds timeout) {
        if (proc_) {
                auto result = future_exit_status_.wait_for(timeout);
                if (result == future_status::timeout) {
                        return error::Error(
                                make_error_condition(errc::timed_out), "Timed out while waiting for process");
                }
                AssertOrReturnError(result == future_status::ready);
                exit_status_ = future_exit_status_.get();
                proc_.reset();
                if (stdout_pipe_ >= 0) {
                        close(stdout_pipe_);
                        stdout_pipe_ = -1;
                }
                if (stderr_pipe_ >= 0) {
                        close(stderr_pipe_);
                        stderr_pipe_ = -1;
                }
        }
        return ErrorBasedOnExitStatus(exit_status_);
}

error::Error Process::AsyncWait(events::EventLoop &loop, AsyncWaitHandler handler) {
        unique_lock lock(async_wait_data_->data_mutex);

        if (async_wait_data_->handler) {
                return error::Error(make_error_condition(errc::operation_in_progress), "Cannot AsyncWait");
        }

        async_wait_data_->event_loop = &loop;
        async_wait_data_->handler = handler;

        if (async_wait_data_->process_ended) {
                // The process has already ended. Schedule the handler immediately.
                auto &async_wait_data = async_wait_data_;
                async_wait_data->event_loop->Post(
                        [async_wait_data, this]() { AsyncWaitInternalHandler(async_wait_data); });
        }

        return error::NoError;
}

error::Error Process::AsyncWait(
        events::EventLoop &loop, AsyncWaitHandler handler, chrono::nanoseconds timeout) {
        timeout_timer_.reset(new events::Timer(loop));

        auto err = AsyncWait(loop, handler);
        if (err != error::NoError) {
                return err;
        }

        timeout_timer_->AsyncWait(timeout, [this, handler](error::Error err) {
                // Move timer here so it gets destroyed after this handler.
                auto timer = std::move(timeout_timer_);
                // Cancel normal AsyncWait() (the process part of it).
                {
                        // DoCancel() requires being locked.
                        unique_lock lock(async_wait_data_->data_mutex);
                        DoCancel();
                }
                if (err != error::NoError) {
                        handler(err.WithContext("Process::Timer"));
                }

                handler(error::Error(make_error_condition(errc::timed_out), "Process::Timer"));
        });

        return error::NoError;
}

void Process::Cancel() {
        unique_lock lock(async_wait_data_->data_mutex);

        if (async_wait_data_->handler && !async_wait_data_->process_ended) {
                auto &async_wait_data = async_wait_data_;
                auto &handler = async_wait_data->handler;
                async_wait_data_->event_loop->Post([handler]() {
                        handler(error::Error(
                                make_error_condition(errc::operation_canceled), "Process::AsyncWait canceled"));
                });
        }

        // DoCancel() requires being locked.
        DoCancel();
}

void Process::DoCancel() {
        // Should already be locked by caller.
        //   unique_lock lock(async_wait_data_->data_mutex);

        timeout_timer_.reset();

        async_wait_data_->event_loop = nullptr;
        async_wait_data_->handler = nullptr;
        async_wait_data_->process_ended = false;
}

void Process::SetupAsyncWait() {
        future_exit_status_ = async(launch::async, [this]() -> int {
                // This function is executed in a separate thread, but the object is guaranteed to
                // still exist while we're in here (because we call `future_exit_status_.get()`
                // during destruction.

                auto status = proc_->get_exit_status();

                auto &async_wait_data = async_wait_data_;

                unique_lock lock(async_wait_data->data_mutex);

                if (async_wait_data->handler) {
                        async_wait_data_->event_loop->Post(
                                [async_wait_data, this]() { AsyncWaitInternalHandler(async_wait_data); });
                }

                async_wait_data->process_ended = true;

                return status;
        });
}

void Process::AsyncWaitInternalHandler(shared_ptr<AsyncWaitData> async_wait_data) {
        timeout_timer_.reset();

        // This function is meant to be executed on the event loop, and the object may have been
        // either cancelled or destroyed before we get here. By having our own copy of the
        // async_wait_data pointer pointer, it survives destruction, and we can test whether we
        // should still proceed here. So note the use of `async_wait_data` instead of
        // `async_wait_data_`.
        unique_lock lock(async_wait_data->data_mutex);

        if (async_wait_data->handler) {
                auto handler = async_wait_data->handler;

                // For next iteration.
                async_wait_data->event_loop = nullptr;
                async_wait_data->handler = nullptr;
                async_wait_data->process_ended = false;

                auto status = GetExitStatus();

                // Unlock in case the handler calls back into this object.
                lock.unlock();
                handler(ErrorBasedOnExitStatus(status));
        }
}

static void CollectLineData(
        string &trailing_line, vector<string> &lines, const char *bytes, size_t len) {
        auto bytes_view = string_view(bytes, len);
        size_t line_start_idx = 0;
        size_t line_end_idx = bytes_view.find("\n", 0);
        if ((trailing_line != "") && (line_end_idx != string_view::npos)) {
                lines.push_back(trailing_line + string(bytes_view, 0, line_end_idx));
                line_start_idx = line_end_idx + 1;
                line_end_idx = bytes_view.find("\n", line_start_idx);
                trailing_line = "";
        }

        while ((line_start_idx < (len - 1)) && (line_end_idx != string_view::npos)) {
                lines.push_back(string(bytes_view, line_start_idx, (line_end_idx - line_start_idx)));
                line_start_idx = line_end_idx + 1;
                line_end_idx = bytes_view.find("\n", line_start_idx);
        }

        if ((line_end_idx == string_view::npos) && (line_start_idx < len)) {
                trailing_line += string(bytes_view, line_start_idx, (len - line_start_idx));
        }
}

ExpectedLineData Process::GenerateLineData(chrono::nanoseconds timeout) {
        if (proc_) {
                return expected::unexpected(
                        MakeError(ProcessAlreadyStartedError, "Cannot generate line data"));
        }

        if (args_.size() == 0) {
                return expected::unexpected(MakeError(
                        ProcessesErrorCode::SpawnError, "No arguments given, cannot spawn a process"));
        }

        // Tiny-process-library doesn't give a good error if the command isn't found (just returns
        // exit code 1). If the path is absolute, it's pretty easy to check if it exists. This won't
        // cover all errors (non-absolute or unset executable bit, for example), but helps a little,
        // at least.
        if (path::IsAbsolute(args_[0])) {
                ifstream f(args_[0]);
                if (!f.good()) {
                        int errnum = errno;
                        return expected::unexpected(error::Error(
                                generic_category().default_error_condition(errnum), "Cannot launch " + args_[0]));
                }
        }

        string trailing_line;
        vector<string> ret;
        proc_ = make_unique<tpl::Process>(
                args_, work_dir_, [&trailing_line, &ret](const char *bytes, size_t len) {
                        CollectLineData(trailing_line, ret, bytes, len);
                });

        if (proc_->get_id() == -1) {
                proc_.reset();
                return expected::unexpected(MakeError(
                        ProcessesErrorCode::SpawnError,
                        "Failed to spawn '" + (args_.size() >= 1 ? args_[0] : "<null>") + "'"));
        }

        SetupAsyncWait();

        auto err = Wait(timeout);
        if (err != error::NoError) {
                return expected::unexpected(err);
        }

        if (trailing_line != "") {
                ret.push_back(trailing_line);
        }

        return ExpectedLineData(ret);
}

io::ExpectedAsyncReaderPtr Process::GetProcessReader(events::EventLoop &loop, int &pipe_ref) {
        if (proc_) {
                return expected::unexpected(
                        MakeError(ProcessAlreadyStartedError, "Cannot get process output"));
        }

        if (pipe_ref >= 0) {
                close(pipe_ref);
                pipe_ref = -1;
        }

        int fds[2];
        int ret = pipe(fds);
        if (ret < 0) {
                int err = errno;
                return expected::unexpected(error::Error(
                        generic_category().default_error_condition(err),
                        "Could not get process stdout reader"));
        }

        pipe_ref = fds[1];

        return make_shared<events::io::AsyncFileDescriptorReader>(loop, fds[0]);
}

io::ExpectedAsyncReaderPtr Process::GetAsyncStdoutReader(events::EventLoop &loop) {
        return GetProcessReader(loop, stdout_pipe_);
}

io::ExpectedAsyncReaderPtr Process::GetAsyncStderrReader(events::EventLoop &loop) {
        return GetProcessReader(loop, stderr_pipe_);
}

int Process::EnsureTerminated() {
        if (!proc_) {
                return exit_status_;
        }

        log::Info("Sending SIGTERM to PID " + to_string(proc_->get_id()));

        Terminate();

        auto result = future_exit_status_.wait_for(max_termination_time_);
        if (result == future_status::timeout) {
                log::Info("Sending SIGKILL to PID " + to_string(proc_->get_id()));
                Kill();
                result = future_exit_status_.wait_for(max_termination_time_);
                if (result != future_status::ready) {
                        // This should not be possible, SIGKILL always terminates.
                        log::Error(
                                "PID " + to_string(proc_->get_id()) + " still not terminated after SIGKILL.");
                        return -1;
                }
        }
        assert(result == future_status::ready);
        exit_status_ = future_exit_status_.get();

        log::Info(
                "PID " + to_string(proc_->get_id()) + " exited with status " + to_string(exit_status_));

        proc_.reset();

        return exit_status_;
}

void Process::Terminate() {
        if (proc_) {
                // At the time of writing, tiny-process-library kills using SIGINT and SIGTERM, for
                // `force = false/true`, respectively. But we want to kill with SIGTERM and SIGKILL,
                // because:
                //
                // 1. SIGINT is not meant to kill interactive processes, whereas SIGTERM is.
                // 2. SIGKILL is required in order to really force, since SIGTERM can be ignored by
                //    the process.
                //
                // If tiny-process-library is fixed, then this can be restored and the part below
                // removed.
                // proc_->kill(false);

                ::kill(proc_->get_id(), SIGTERM);
                ::kill(-proc_->get_id(), SIGTERM);
        }
}

void Process::Kill() {
        if (proc_) {
                // See comment in Terminate().
                // proc_->kill(true);

                ::kill(proc_->get_id(), SIGKILL);
                ::kill(-proc_->get_id(), SIGKILL);
        }
}

void ProcessReaderFunctor::operator()(const char *bytes, size_t n) {
        if (callback_) {
                callback_(bytes, n);
        }

        if (fd_ < 0) {
                return;
        }

        size_t written = 0;
        while (written < n) {
                auto ret = write(fd_, bytes, n);
                if (ret < 0) {
                        int err = errno;
                        log::Error(
                                string {"Error while writing process output to main thread: "} + strerror(err));
                        fd_ = -1;
                        return;
                }

                written += ret;
        }
}

} // namespace processes
} // namespace common
} // namespace mender

1	// Copyright 2023 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	#include <common/processes.hpp>
16
17	#include <string>
18	#include <string_view>
19
20	#include <common/events_io.hpp>
21	#include <common/io.hpp>
22	#include <common/log.hpp>
23	#include <common/path.hpp>
24
25	using namespace std;
26
27	namespace mender {
28	namespace common {
29	namespace processes {
30
31	const chrono::seconds MAX_TERMINATION_TIME(10);
32
33	namespace io = mender::common::io;
34	namespace log = mender::common::log;
35	namespace path = mender::common::path;
36
37	class ProcessReaderFunctor {	7,328✔
38	public:
39	void operator()(const char *bytes, size_t n);
40
41	// Note: ownership is not held here, but in Process.
42	int fd_;
43
44	OutputCallback callback_;
45	};
46
47	Process::Process(const vector<string> &args) :	5,206✔
48	args_ {args},	2,603✔
49	max_termination_time_ {MAX_TERMINATION_TIME} {	2,603✔
50	async_wait_data_ = make_shared<AsyncWaitData>();	2,603✔
51	}	5,206✔
52
53	Process::~Process() {	6,039✔
54	{
55	unique_lock lock(async_wait_data_->data_mutex);	2,603✔
56	// DoCancel() requires being locked.
57	DoCancel();	2,603✔
58	}	2,603✔
59
60	EnsureTerminated();	2,603✔
61
62	if (stdout_pipe_ >= 0) {	2,603✔
63	close(stdout_pipe_);	×
64	}
65	if (stderr_pipe_ >= 0) {	2,603✔
66	close(stderr_pipe_);	×
67	}
68	}	8,642✔
69
70	error::Error Process::Start(OutputCallback stdout_callback, OutputCallback stderr_callback) {	2,562✔
71	if (proc_) {	2,562✔
72	return MakeError(ProcessAlreadyStartedError, "Cannot start process");	×
73	}
74
75	// Tiny-process-library doesn't give a good error if the command isn't found (just returns
76	// exit code 1). If the path is absolute, it's pretty easy to check if it exists. This won't
77	// cover all errors (non-absolute or unset executable bit, for example), but helps a little,
78	// at least.
79	if (args_.size() > 0 && path::IsAbsolute(args_[0])) {	2,562✔
80	ifstream f(args_[0]);	1,882✔
81	if (!f.good()) {	1,882✔
82	int errnum = errno;	1✔
83	return error::Error(
84	generic_category().default_error_condition(errnum), "Cannot launch " + args_[0]);	2✔
85	}
86	}	1,882✔
87
88	OutputCallback maybe_stdout_callback;	2,561✔
89	if (stdout_pipe_ >= 0 \|\| stdout_callback) {	2,561✔
90	maybe_stdout_callback = ProcessReaderFunctor {stdout_pipe_, stdout_callback};	3,664✔
91	}
92	OutputCallback maybe_stderr_callback;	2,561✔
93	if (stderr_pipe_ >= 0 \|\| stderr_callback) {	2,561✔
94	maybe_stderr_callback = ProcessReaderFunctor {stderr_pipe_, stderr_callback};	3,664✔
95	}
96
97	proc_ =
98	make_unique<tpl::Process>(args_, work_dir_, maybe_stdout_callback, maybe_stderr_callback);	5,122✔
99
100	if (proc_->get_id() == -1) {	2,561✔
101	proc_.reset();
102	return MakeError(
103	ProcessesErrorCode::SpawnError,
104	"Failed to spawn '" + (args_.size() >= 1 ? args_[0] : "<null>") + "'");	×
105	}
106
107	SetupAsyncWait();	2,561✔
108
109	return error::NoError;	2,561✔
110	}
111
112	error::Error Process::Run() {	642✔
113	auto err = Start();	1,284✔
114	if (err != error::NoError) {	642✔
115	log::Error(err.String());	×
116	}
117	return Wait();	1,284✔
118	}
119
120	static error::Error ErrorBasedOnExitStatus(int exit_status) {	4,665✔
121	if (exit_status != 0) {	4,665✔
122	return MakeError(
123	NonZeroExitStatusError, "Process exited with status " + to_string(exit_status));	1,006✔
124	} else {
125	return error::NoError;	4,162✔
126	}
127	}
128
129	error::Error Process::Wait() {	2,747✔
130	if (proc_) {	2,747✔
131	exit_status_ = future_exit_status_.get();	2,473✔
132	proc_.reset();
133	if (stdout_pipe_ >= 0) {	2,473✔
134	close(stdout_pipe_);	2✔
135	stdout_pipe_ = -1;	2✔
136	}
137	if (stderr_pipe_ >= 0) {	2,473✔
138	close(stderr_pipe_);	2✔
139	stderr_pipe_ = -1;	2✔
140	}
141	}
142	return ErrorBasedOnExitStatus(exit_status_);	2,747✔
143	}
144
145	error::Error Process::Wait(chrono::nanoseconds timeout) {	90✔
146	if (proc_) {	90✔
147	auto result = future_exit_status_.wait_for(timeout);	90✔
148	if (result == future_status::timeout) {	90✔
149	return error::Error(
150	make_error_condition(errc::timed_out), "Timed out while waiting for process");	×
151	}
152	AssertOrReturnError(result == future_status::ready);	90✔
153	exit_status_ = future_exit_status_.get();	90✔
154	proc_.reset();
155	if (stdout_pipe_ >= 0) {	90✔
156	close(stdout_pipe_);	×
157	stdout_pipe_ = -1;	×
158	}
159	if (stderr_pipe_ >= 0) {	90✔
160	close(stderr_pipe_);	×
161	stderr_pipe_ = -1;	×
162	}
163	}
164	return ErrorBasedOnExitStatus(exit_status_);	90✔
165	}
166
167	error::Error Process::AsyncWait(events::EventLoop &loop, AsyncWaitHandler handler) {	1,835✔
168	unique_lock lock(async_wait_data_->data_mutex);	1,835✔
169
170	if (async_wait_data_->handler) {	1,835✔
171	return error::Error(make_error_condition(errc::operation_in_progress), "Cannot AsyncWait");	×
172	}
173
174	async_wait_data_->event_loop = &loop;	1,835✔
175	async_wait_data_->handler = handler;	1,835✔
176
177	if (async_wait_data_->process_ended) {	1,835✔
178	// The process has already ended. Schedule the handler immediately.
179	auto &async_wait_data = async_wait_data_;
180	async_wait_data->event_loop->Post(	×
181	[async_wait_data, this]() { AsyncWaitInternalHandler(async_wait_data); });	×
182	}
183
184	return error::NoError;	1,835✔
185	}	1,835✔
186
187	error::Error Process::AsyncWait(	1,830✔
188	events::EventLoop &loop, AsyncWaitHandler handler, chrono::nanoseconds timeout) {
189	timeout_timer_.reset(new events::Timer(loop));	1,830✔
190
191	auto err = AsyncWait(loop, handler);	1,830✔
192	if (err != error::NoError) {	1,830✔
193	return err;	×
194	}
195
196	timeout_timer_->AsyncWait(timeout, [this, handler](error::Error err) {	5,490✔
197	// Move timer here so it gets destroyed after this handler.
198	auto timer = std::move(timeout_timer_);	5✔
199	// Cancel normal AsyncWait() (the process part of it).
200	{
201	// DoCancel() requires being locked.
202	unique_lock lock(async_wait_data_->data_mutex);	5✔
203	DoCancel();	5✔
204	}	5✔
205	if (err != error::NoError) {	5✔
206	handler(err.WithContext("Process::Timer"));	×
207	}
208
209	handler(error::Error(make_error_condition(errc::timed_out), "Process::Timer"));	15✔
210	});	5✔
211
212	return error::NoError;	1,830✔
213	}
214
215	void Process::Cancel() {	7✔
216	unique_lock lock(async_wait_data_->data_mutex);	7✔
217
218	if (async_wait_data_->handler && !async_wait_data_->process_ended) {	7✔
219	auto &async_wait_data = async_wait_data_;
220	auto &handler = async_wait_data->handler;	1✔
221	async_wait_data_->event_loop->Post([handler]() {	6✔
222	handler(error::Error(	1✔
223	make_error_condition(errc::operation_canceled), "Process::AsyncWait canceled"));	2✔
224	});	1✔
225	}
226
227	// DoCancel() requires being locked.
228	DoCancel();	7✔
229	}	7✔
230
231	void Process::DoCancel() {	2,615✔
232	// Should already be locked by caller.
233	// unique_lock lock(async_wait_data_->data_mutex);
234
235	timeout_timer_.reset();
236
237	async_wait_data_->event_loop = nullptr;	2,615✔
238	async_wait_data_->handler = nullptr;	2,615✔
239	async_wait_data_->process_ended = false;	2,615✔
240	}	2,615✔
241
242	void Process::SetupAsyncWait() {	2,651✔
243	future_exit_status_ = async(launch::async, [this]() -> int {	2,651✔
244	// This function is executed in a separate thread, but the object is guaranteed to
245	// still exist while we're in here (because we call `future_exit_status_.get()`
246	// during destruction.
247
248	auto status = proc_->get_exit_status();	2,651✔
249
250	auto &async_wait_data = async_wait_data_;	2,651✔
251
252	unique_lock lock(async_wait_data->data_mutex);	2,651✔
253
254	if (async_wait_data->handler) {	2,651✔
255	async_wait_data_->event_loop->Post(	3,656✔
256	[async_wait_data, this]() { AsyncWaitInternalHandler(async_wait_data); });	10,968✔
257	}
258
259	async_wait_data->process_ended = true;	2,651✔
260
261	return status;	2,651✔
262	});	5,302✔
263	}	2,651✔
264
265	void Process::AsyncWaitInternalHandler(shared_ptr<AsyncWaitData> async_wait_data) {	1,828✔
266	timeout_timer_.reset();
267
268	// This function is meant to be executed on the event loop, and the object may have been
269	// either cancelled or destroyed before we get here. By having our own copy of the
270	// async_wait_data pointer pointer, it survives destruction, and we can test whether we
271	// should still proceed here. So note the use of `async_wait_data` instead of
272	// `async_wait_data_`.
273	unique_lock lock(async_wait_data->data_mutex);	1,828✔
274
275	if (async_wait_data->handler) {	1,828✔
276	auto handler = async_wait_data->handler;	1,828✔
277
278	// For next iteration.
279	async_wait_data->event_loop = nullptr;	1,828✔
280	async_wait_data->handler = nullptr;	1,828✔
281	async_wait_data->process_ended = false;	1,828✔
282
283	auto status = GetExitStatus();	1,828✔
284
285	// Unlock in case the handler calls back into this object.
286	lock.unlock();	1,828✔
287	handler(ErrorBasedOnExitStatus(status));	3,656✔
288	}
289	}	1,828✔
290
291	static void CollectLineData(	287✔
292	string &trailing_line, vector<string> &lines, const char *bytes, size_t len) {
293	auto bytes_view = string_view(bytes, len);
294	size_t line_start_idx = 0;
295	size_t line_end_idx = bytes_view.find("\n", 0);	287✔
296	if ((trailing_line != "") && (line_end_idx != string_view::npos)) {	287✔
297	lines.push_back(trailing_line + string(bytes_view, 0, line_end_idx));	×
298	line_start_idx = line_end_idx + 1;	×
299	line_end_idx = bytes_view.find("\n", line_start_idx);	×
300	trailing_line = "";	×
301	}
302
303	while ((line_start_idx < (len - 1)) && (line_end_idx != string_view::npos)) {	649✔
304	lines.push_back(string(bytes_view, line_start_idx, (line_end_idx - line_start_idx)));	362✔
305	line_start_idx = line_end_idx + 1;	362✔
306	line_end_idx = bytes_view.find("\n", line_start_idx);	362✔
307	}
308
309	if ((line_end_idx == string_view::npos) && (line_start_idx < len)) {	287✔
310	trailing_line += string(bytes_view, line_start_idx, (len - line_start_idx));	4✔
311	}
312	}	287✔
313
314	ExpectedLineData Process::GenerateLineData(chrono::nanoseconds timeout) {	90✔
315	if (proc_) {	90✔
316	return expected::unexpected(	×
317	MakeError(ProcessAlreadyStartedError, "Cannot generate line data"));	×
318	}
319
320	if (args_.size() == 0) {	90✔
321	return expected::unexpected(MakeError(	×
322	ProcessesErrorCode::SpawnError, "No arguments given, cannot spawn a process"));	×
323	}
324
325	// Tiny-process-library doesn't give a good error if the command isn't found (just returns
326	// exit code 1). If the path is absolute, it's pretty easy to check if it exists. This won't
327	// cover all errors (non-absolute or unset executable bit, for example), but helps a little,
328	// at least.
329	if (path::IsAbsolute(args_[0])) {	90✔
330	ifstream f(args_[0]);	84✔
331	if (!f.good()) {	84✔
332	int errnum = errno;	×
333	return expected::unexpected(error::Error(	×
334	generic_category().default_error_condition(errnum), "Cannot launch " + args_[0]));	×
335	}
336	}	84✔
337
338	string trailing_line;
339	vector<string> ret;
340	proc_ = make_unique<tpl::Process>(	90✔
341	args_, work_dir_, [&trailing_line, &ret](const char *bytes, size_t len) {	180✔
342	CollectLineData(trailing_line, ret, bytes, len);	287✔
343	});	287✔
344
345	if (proc_->get_id() == -1) {	90✔
346	proc_.reset();
347	return expected::unexpected(MakeError(	×
348	ProcessesErrorCode::SpawnError,
349	"Failed to spawn '" + (args_.size() >= 1 ? args_[0] : "<null>") + "'"));	×
350	}
351
352	SetupAsyncWait();	90✔
353
354	auto err = Wait(timeout);	90✔
355	if (err != error::NoError) {	90✔
356	return expected::unexpected(err);	2✔
357	}
358
359	if (trailing_line != "") {	89✔
360	ret.push_back(trailing_line);	2✔
361	}
362
363	return ExpectedLineData(ret);	89✔
364	}	90✔
365
366	io::ExpectedAsyncReaderPtr Process::GetProcessReader(events::EventLoop &loop, int &pipe_ref) {	4✔
367	if (proc_) {	4✔
368	return expected::unexpected(	×
369	MakeError(ProcessAlreadyStartedError, "Cannot get process output"));	×
370	}
371
372	if (pipe_ref >= 0) {	4✔
373	close(pipe_ref);	×
374	pipe_ref = -1;	×
375	}
376
377	int fds[2];
378	int ret = pipe(fds);	4✔
379	if (ret < 0) {	4✔
380	int err = errno;	×
381	return expected::unexpected(error::Error(	×
382	generic_category().default_error_condition(err),	×
383	"Could not get process stdout reader"));	×
384	}
385
386	pipe_ref = fds[1];	4✔
387
388	return make_shared<events::io::AsyncFileDescriptorReader>(loop, fds[0]);	8✔
389	}
390
391	io::ExpectedAsyncReaderPtr Process::GetAsyncStdoutReader(events::EventLoop &loop) {	2✔
392	return GetProcessReader(loop, stdout_pipe_);	2✔
393	}
394
395	io::ExpectedAsyncReaderPtr Process::GetAsyncStderrReader(events::EventLoop &loop) {	2✔
396	return GetProcessReader(loop, stderr_pipe_);	2✔
397	}
398
399	int Process::EnsureTerminated() {	2,628✔
400	if (!proc_) {	2,628✔
401	return exit_status_;	2,540✔
402	}
403
404	log::Info("Sending SIGTERM to PID " + to_string(proc_->get_id()));	88✔
405
406	Terminate();	88✔
407
408	auto result = future_exit_status_.wait_for(max_termination_time_);	88✔
409	if (result == future_status::timeout) {	88✔
410	log::Info("Sending SIGKILL to PID " + to_string(proc_->get_id()));	×
411	Kill();	×
412	result = future_exit_status_.wait_for(max_termination_time_);	×
413	if (result != future_status::ready) {	×
414	// This should not be possible, SIGKILL always terminates.
415	log::Error(	×
416	"PID " + to_string(proc_->get_id()) + " still not terminated after SIGKILL.");	×
417	return -1;	×
418	}
419	}
420	assert(result == future_status::ready);
421	exit_status_ = future_exit_status_.get();	88✔
422
423	log::Info(	88✔
424	"PID " + to_string(proc_->get_id()) + " exited with status " + to_string(exit_status_));	176✔
425
426	proc_.reset();
427
428	return exit_status_;	88✔
429	}
430
431	void Process::Terminate() {	89✔
432	if (proc_) {	89✔
433	// At the time of writing, tiny-process-library kills using SIGINT and SIGTERM, for
434	// `force = false/true`, respectively. But we want to kill with SIGTERM and SIGKILL,
435	// because:
436	//
437	// 1. SIGINT is not meant to kill interactive processes, whereas SIGTERM is.
438	// 2. SIGKILL is required in order to really force, since SIGTERM can be ignored by
439	// the process.
440	//
441	// If tiny-process-library is fixed, then this can be restored and the part below
442	// removed.
443	// proc_->kill(false);
444
445	::kill(proc_->get_id(), SIGTERM);	89✔
446	::kill(-proc_->get_id(), SIGTERM);	89✔
447	}
448	}	89✔
449
450	void Process::Kill() {	1✔
451	if (proc_) {	1✔
452	// See comment in Terminate().
453	// proc_->kill(true);
454
455	::kill(proc_->get_id(), SIGKILL);	1✔
456	::kill(-proc_->get_id(), SIGKILL);	1✔
457	}
458	}	1✔
459
460	void ProcessReaderFunctor::operator()(const char *bytes, size_t n) {	1,046✔
461	if (callback_) {	1,046✔
462	callback_(bytes, n);	1,005✔
463	}
464
465	if (fd_ < 0) {	1,046✔
466	return;
467	}
468
469	size_t written = 0;
470	while (written < n) {	14✔
471	auto ret = write(fd_, bytes, n);	8✔
472	if (ret < 0) {	8✔
473	int err = errno;	2✔
474	log::Error(	2✔
475	string {"Error while writing process output to main thread: "} + strerror(err));	2✔
476	fd_ = -1;	2✔
477	return;	2✔
478	}
479
480	written += ret;	6✔
481	}
482	}
483
484	} // namespace processes
485	} // namespace common
486	} // namespace mender

mendersoftware / mender / 2479575822

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous