1499142629

Committed 16 Oct 2024 06:58PM UTC coverage: 76.305% (-0.06%) from 76.361%

Build # 1499142629

Build Type

push

gitlab-ci

Committed by

lluiscampos

Commit Message

fix: Invalidate cached inventory

Changelog: Invalidate cached inventory data on unauthentication event
to prevent an issue with which the client would not send inventory
data to the server after being unauthorized and authorized again.

Ticket: MEN-7617

Signed-off-by: Lluis Campos <lluis.campos@northern.tech>

Run Details

0 of 4 new or added lines in 1 file covered. (0.0%)

268 existing lines in 7 files now uncovered.

7310 of 9580 relevant lines covered (76.3%)

11291.79 hits per line

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

65.79

/src/mender-update/cli/actions.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 <mender-update/cli/actions.hpp>

#include <algorithm>
#include <iostream>
#include <string>

#include <artifact/config.hpp>

#include <common/common.hpp>
#include <common/error.hpp>
#include <common/events.hpp>
#include <common/expected.hpp>
#include <common/key_value_database.hpp>
#include <common/log.hpp>
#include <common/path.hpp>
#include <common/processes.hpp>

#include <mender-update/cli/cli.hpp>
#include <mender-update/daemon.hpp>
#include <mender-update/standalone.hpp>

#ifdef MENDER_EMBED_MENDER_AUTH
#include <mender-auth/cli/actions.hpp>
#endif

namespace mender {
namespace update {
namespace cli {

namespace processes = mender::common::processes;
namespace conf = mender::client_shared::conf;
namespace daemon = mender::update::daemon;
namespace database = mender::common::key_value_database;
namespace error = mender::common::error;
namespace events = mender::common::events;
namespace expected = mender::common::expected;
namespace http = mender::common::http;
namespace kv_db = mender::common::key_value_database;
namespace log = mender::common::log;
namespace path = mender::common::path;
namespace standalone = mender::update::standalone;

static error::Error DoMaybeInstallBootstrapArtifact(context::MenderContext &main_context) {
        const string bootstrap_artifact_path {
                main_context.GetConfig().paths.GetBootstrapArtifactFile()};
        // Check if the DB is populated - then install conditionally
        auto &db = main_context.GetMenderStoreDB();
        auto exp_key = db.Read(main_context.artifact_name_key);
        if (exp_key) {
                // Key exists. Do nothing
                return error::NoError;
        }
        error::Error err = exp_key.error();
        if (err.code != kv_db::MakeError(kv_db::KeyError, "Key Not found").code) {
                return err;
        }

        // Key does not exist, install the bootstrap artifact if it exists
        if (!path::FileExists(bootstrap_artifact_path)) {
                log::Debug("No Bootstrap Artifact found at: " + bootstrap_artifact_path);
                error::Error err =
                        db.Write(main_context.artifact_name_key, common::ByteVectorFromString("unknown"));
                if (err != error::NoError) {
                        return err;
                }
                return error::NoError;
        }
        log::Info("Installing the bootstrap Artifact");
        events::EventLoop loop;
        standalone::Context ctx {main_context, loop};
        auto result = standalone::Install(
                ctx,
                bootstrap_artifact_path,
                artifact::config::Signature::Skip,
                standalone::InstallOptions::NoStdout);

        if (result.err != error::NoError) {
                error::Error err =
                        db.Write(main_context.artifact_name_key, common::ByteVectorFromString("unknown"));
                return result.err.FollowedBy(err).WithContext("Failed to install the bootstrap Artifact");
        }
        return error::NoError;
}

error::Error MaybeInstallBootstrapArtifact(context::MenderContext &main_context) {
        const string bootstrap_artifact_path {
                main_context.GetConfig().paths.GetBootstrapArtifactFile()};
        error::Error err = DoMaybeInstallBootstrapArtifact(main_context);

        // Unconditionally delete the bootstrap Artifact
        if (path::FileExists(bootstrap_artifact_path)) {
                error::Error delete_err = path::FileDelete(bootstrap_artifact_path);
                if (delete_err != error::NoError) {
                        return err.FollowedBy(
                                delete_err.WithContext("Failed to delete the bootstrap Artifact"));
                }
        }
        return err;
}

error::Error ShowArtifactAction::Execute(context::MenderContext &main_context) {
        error::Error err = MaybeInstallBootstrapArtifact(main_context);
        if (err != error::NoError) {
                return err;
        }

        auto exp_provides = main_context.LoadProvides();
        if (!exp_provides) {
                return exp_provides.error();
        }

        auto &provides = exp_provides.value();
        if (provides.count("artifact_name") == 0 || provides["artifact_name"] == "") {
                cout << "unknown" << endl;
        } else {
                cout << provides["artifact_name"] << endl;
        }
        return error::NoError;
}

error::Error ShowProvidesAction::Execute(context::MenderContext &main_context) {
        error::Error err = MaybeInstallBootstrapArtifact(main_context);
        if (err != error::NoError) {
                return err;
        }

        auto exp_provides = main_context.LoadProvides();
        if (!exp_provides) {
                return exp_provides.error();
        }

        auto &provides = exp_provides.value();
        for (const auto &elem : provides) {
                cout << elem.first << "=" << elem.second << endl;
        }

        return error::NoError;
}

static error::Error ResultHandler(standalone::ResultAndError result) {
        using Result = standalone::Result;

        if (result.err != error::NoError) {
                log::Error(result.err.String());
        } else if (ResultContains(result.result, Result::Failed)) {
                // All error states, make sure they have an error.
                result.err = error::MakeError(error::ExitWithFailureError, "");
        }

        using r = Result;
        auto contains = [&result](r val) { return ResultContains(result.result, val); };
        auto none_of = [&result](r val) { return ResultNoneOf(result.result, val); };
        auto add = [](string &str, const string &content) {
                if (str.size() > 0) {
                        str += " ";
                }
                str += content;
        };

        string operation_done;
        string operation_failure;

        // For failure case, include which attempted operation failed.
        if (contains(r::DownloadFailed)) {
                operation_failure = "Streaming failed.";
        } else if (contains(r::InstallFailed)) {
                operation_failure = "Installation failed.";
        } else if (contains(r::CommitFailed)) {
                operation_failure = "Committing failed.";
        }

        // For done case, include which operation succeded.
        if (contains(r::Committed) and none_of(r::Installed)) {
                operation_done = "Committed.";
        } else if (contains(r::Installed) and none_of(r::Committed)) {
                operation_done =
                        "Installed, but not committed.\n"
                        "Use 'commit' to update, or 'rollback' to roll back the update.";
        } else if (contains(r::Downloaded) and none_of(r::Installed)) {
                operation_done = "Streamed to storage, but not installed/enabled.";
        } else if (contains(r::Installed | r::Committed)) {
                operation_done = "Installed and committed.";
        } else if (contains(r::NoUpdateInProgress)) {
                operation_done = "No update in progress.";
        } else if (contains(r::Cleaned) and none_of(~r::Cleaned)) {
                // Only include this message if it was the only thing done.
                operation_done = "Cleaned up.";
        }

        // Pick which one of the done/failure cases to use. If the failure happened after the
        // commit, we pick the done case, since the operation was still completed.
        string &operation = (contains(r::Failed) and none_of(r::FailedInPostCommit | r::CleanupFailed))
                                                        ? operation_failure
                                                        : operation_done;

        string prefix;
        string additional;

        if (contains(r::AutoCommitWanted) and contains(r::Installed)
                and (contains(r::Committed) or contains(r::Failed))) {
                prefix = "Update Module doesn't support rollback. Committing immediately.";
        }

        if (contains(r::RollbackFailed)) {
                additional =
                        "Rollback failed. "
                        "System may be in an inconsistent state.";
        } else if (contains(r::NoRollback)) {
                additional =
                        "Update Module does not support rollback. "
                        "System may be in an inconsistent state.";
        } else if (contains(r::NoRollbackNecessary)) {
                additional = "System not modified.";
        } else if (contains(r::RolledBack)) {
                additional = "Rolled back.";
        }

        if (contains(r::FailedInPostCommit)) {
                add(additional, "One or more post-commit steps failed.");
        }
        if (contains(r::CleanupFailed)) {
                add(additional, "Cleanup failed.");
        }

        if (contains(r::RebootRequired)) {
                add(additional, "At least one payload requested a reboot of the device it updated.");
                if (result.err == error::NoError) {
                        result.err = context::MakeError(context::RebootRequiredError, "Reboot required");
                }
        }

        if (prefix.size() > 0) {
                cout << prefix << endl;
        }
        if (operation.size() > 0) {
                cout << operation << endl;
        }
        if (additional.size() > 0) {
                cout << additional << endl;
        }

        return result.err;
}

error::Error InstallAction::Execute(context::MenderContext &main_context) {
        error::Error err = MaybeInstallBootstrapArtifact(main_context);
        if (err != error::NoError) {
                return err;
        }
        events::EventLoop loop;
        standalone::Context ctx {main_context, loop};
        ctx.stop_before = std::move(stop_before_);
        auto result = standalone::Install(ctx, src_);
        err = ResultHandler(result);
        if (!reboot_exit_code_
                && err.code == context::MakeError(context::RebootRequiredError, "").code) {
                // If reboot exit code isn't requested, then this type of error should be treated as
                // plain success.
                err = error::NoError;
        }
        return err;
}

error::Error ResumeAction::Execute(context::MenderContext &main_context) {
        events::EventLoop loop;
        standalone::Context ctx {main_context, loop};
        ctx.stop_before = std::move(stop_before_);

        auto result = standalone::Resume(ctx);
        auto err = ResultHandler(result);

        if (!reboot_exit_code_
                && err.code == context::MakeError(context::RebootRequiredError, "").code) {
                // If reboot exit code isn't requested, then this type of error should be treated as
                // plain success.
                err = error::NoError;
        }
        return err;
}

error::Error CommitAction::Execute(context::MenderContext &main_context) {
        events::EventLoop loop;
        standalone::Context ctx {main_context, loop};
        ctx.stop_before = std::move(stop_before_);
        auto result = standalone::Commit(ctx);
        return ResultHandler(result);
}

error::Error RollbackAction::Execute(context::MenderContext &main_context) {
        events::EventLoop loop;
        standalone::Context ctx {main_context, loop};
        ctx.stop_before = std::move(stop_before_);
        auto result = standalone::Rollback(ctx);
        return ResultHandler(result);
}

error::Error DaemonAction::Execute(context::MenderContext &main_context) {
        events::EventLoop event_loop;
        daemon::Context ctx(main_context, event_loop);

#if not defined(MENDER_USE_DBUS) and defined(MENDER_EMBED_MENDER_AUTH)
        // Passphrase is not currently supported when launching from mender-update cli.
        auto key_store = mender::auth::cli::KeystoreFromConfig(ctx.mender_context.GetConfig(), "");
        ctx.authenticator.SetCryptoArgs(
                {key_store->KeyName(), key_store->PassPhrase(), key_store->SSLEngine()});
#endif

        daemon::StateMachine state_machine(ctx, event_loop);
        state_machine.LoadStateFromDb();
        error::Error err = MaybeInstallBootstrapArtifact(main_context);
        if (err != error::NoError) {
                return err;
        }

        event_loop.Post([]() {
                log::Info("The update client daemon is now ready to handle incoming deployments");
        });

        return state_machine.Run();
}

static expected::ExpectedString GetPID() {
        processes::Process proc({"systemctl", "show", "--property=MainPID", "mender-updated"});
        auto exp_line_data = proc.GenerateLineData();
        if (!exp_line_data) {
                return expected::unexpected(
                        exp_line_data.error().WithContext("Failed to get the MainPID from systemctl"));
        }
        if (exp_line_data.value().size() < 1) {
                return expected::unexpected(error::Error(
                        make_error_condition(errc::message_size), "No output received from systemctl"));
        }
        const string prefix {"MainPID="};
        const string line = exp_line_data.value().at(0);
        auto split_index = line.find(prefix);
        if (split_index == string::npos) {
                return expected::unexpected(error::Error(
                        make_error_condition(errc::no_message), "No output received from systemctl"));
        }
        if (split_index != 0) {
                return expected::unexpected(error::Error(
                        make_error_condition(errc::bad_message), "Unexpected output from systemctl"));
        }
        const string PID = line.substr(split_index + prefix.size(), line.size());
        if (PID == "" or PID == "0") {
                return expected::unexpected(error::Error(
                        make_error_condition(errc::no_message),
                        "No PID found for mender-updated. The service is not running"));
        }
        return PID;
}

static error::Error SendSignal(const string &signal, const string &pid) {
        const vector<string> command {"kill", "-" + signal, pid};
        const string command_string = common::JoinStrings(command, " ");
        processes::Process proc(command);
        auto err = proc.Start();
        if (err != error::NoError) {
                return err.WithContext("Command '" + command_string + "'");
        }
        return proc.Wait().WithContext("Command '" + command_string + "'");
}

error::Error SendInventoryAction::Execute(context::MenderContext &main_context) {
        auto pid = GetPID();
        if (!pid) {
                return pid.error().WithContext("Failed to force an inventory update");
        }

        return SendSignal("SIGUSR2", pid.value()).WithContext("Failed to force an inventory update");
}

error::Error CheckUpdateAction::Execute(context::MenderContext &main_context) {
        auto pid = GetPID();
        if (!pid) {
                return pid.error().WithContext("Failed to force an update check");
        }
        return SendSignal("SIGUSR1", pid.value()).WithContext("Failed to force an update check");
}

} // namespace cli
} // namespace update
} // 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 <mender-update/cli/actions.hpp>
16
17	#include <algorithm>
18	#include <iostream>
19	#include <string>
20
21	#include <artifact/config.hpp>
22
23	#include <common/common.hpp>
24	#include <common/error.hpp>
25	#include <common/events.hpp>
26	#include <common/expected.hpp>
27	#include <common/key_value_database.hpp>
28	#include <common/log.hpp>
29	#include <common/path.hpp>
30	#include <common/processes.hpp>
31
32	#include <mender-update/cli/cli.hpp>
33	#include <mender-update/daemon.hpp>
34	#include <mender-update/standalone.hpp>
35
36	#ifdef MENDER_EMBED_MENDER_AUTH
37	#include <mender-auth/cli/actions.hpp>
38	#endif
39
40	namespace mender {
41	namespace update {
42	namespace cli {
43
44	namespace processes = mender::common::processes;
45	namespace conf = mender::client_shared::conf;
46	namespace daemon = mender::update::daemon;
47	namespace database = mender::common::key_value_database;
48	namespace error = mender::common::error;
49	namespace events = mender::common::events;
50	namespace expected = mender::common::expected;
51	namespace http = mender::common::http;
52	namespace kv_db = mender::common::key_value_database;
53	namespace log = mender::common::log;
54	namespace path = mender::common::path;
55	namespace standalone = mender::update::standalone;
56
57	static error::Error DoMaybeInstallBootstrapArtifact(context::MenderContext &main_context) {	107✔
58	const string bootstrap_artifact_path {
59	main_context.GetConfig().paths.GetBootstrapArtifactFile()};
60	// Check if the DB is populated - then install conditionally
61	auto &db = main_context.GetMenderStoreDB();	107✔
62	auto exp_key = db.Read(main_context.artifact_name_key);	107✔
63	if (exp_key) {	107✔
64	// Key exists. Do nothing
65	return error::NoError;	58✔
66	}
67	error::Error err = exp_key.error();	49✔
68	if (err.code != kv_db::MakeError(kv_db::KeyError, "Key Not found").code) {	49✔
69	return err;	×
70	}
71
72	// Key does not exist, install the bootstrap artifact if it exists
73	if (!path::FileExists(bootstrap_artifact_path)) {	49✔
74	log::Debug("No Bootstrap Artifact found at: " + bootstrap_artifact_path);	46✔
75	error::Error err =
76	db.Write(main_context.artifact_name_key, common::ByteVectorFromString("unknown"));	46✔
77	if (err != error::NoError) {	46✔
78	return err;	×
79	}
80	return error::NoError;	46✔
81	}
82	log::Info("Installing the bootstrap Artifact");	6✔
83	events::EventLoop loop;
84	standalone::Context ctx {main_context, loop};	6✔
85	auto result = standalone::Install(
86	ctx,
87	bootstrap_artifact_path,
88	artifact::config::Signature::Skip,
89	standalone::InstallOptions::NoStdout);	3✔
90
91	if (result.err != error::NoError) {	3✔
92	error::Error err =
93	db.Write(main_context.artifact_name_key, common::ByteVectorFromString("unknown"));	×
94	return result.err.FollowedBy(err).WithContext("Failed to install the bootstrap Artifact");	×
95	}
96	return error::NoError;	3✔
97	}
98
99	error::Error MaybeInstallBootstrapArtifact(context::MenderContext &main_context) {	107✔
100	const string bootstrap_artifact_path {
101	main_context.GetConfig().paths.GetBootstrapArtifactFile()};
102	error::Error err = DoMaybeInstallBootstrapArtifact(main_context);	107✔
103
104	// Unconditionally delete the bootstrap Artifact
105	if (path::FileExists(bootstrap_artifact_path)) {	107✔
106	error::Error delete_err = path::FileDelete(bootstrap_artifact_path);	3✔
107	if (delete_err != error::NoError) {	3✔
108	return err.FollowedBy(
109	delete_err.WithContext("Failed to delete the bootstrap Artifact"));	×
110	}
111	}
112	return err;	107✔
113	}
114
115	error::Error ShowArtifactAction::Execute(context::MenderContext &main_context) {	2✔
116	error::Error err = MaybeInstallBootstrapArtifact(main_context);	2✔
117	if (err != error::NoError) {	2✔
118	return err;	×
119	}
120
121	auto exp_provides = main_context.LoadProvides();	2✔
122	if (!exp_provides) {	2✔
123	return exp_provides.error();	×
124	}
125
126	auto &provides = exp_provides.value();	2✔
127	if (provides.count("artifact_name") == 0 \|\| provides["artifact_name"] == "") {	8✔
128	cout << "unknown" << endl;	×
129	} else {
130	cout << provides["artifact_name"] << endl;	6✔
131	}
132	return error::NoError;	2✔
133	}
134
135	error::Error ShowProvidesAction::Execute(context::MenderContext &main_context) {	40✔
136	error::Error err = MaybeInstallBootstrapArtifact(main_context);	40✔
137	if (err != error::NoError) {	40✔
138	return err;	×
139	}
140
141	auto exp_provides = main_context.LoadProvides();	40✔
142	if (!exp_provides) {	40✔
143	return exp_provides.error();	×
144	}
145
146	auto &provides = exp_provides.value();	40✔
147	for (const auto &elem : provides) {	137✔
148	cout << elem.first << "=" << elem.second << endl;	97✔
149	}
150
151	return error::NoError;	40✔
152	}
153
154	static error::Error ResultHandler(standalone::ResultAndError result) {	87✔
155	using Result = standalone::Result;
156
157	if (result.err != error::NoError) {	87✔
158	log::Error(result.err.String());	48✔
159	} else if (ResultContains(result.result, Result::Failed)) {	63✔
160	// All error states, make sure they have an error.
161	result.err = error::MakeError(error::ExitWithFailureError, "");	4✔
162	}
163
164	using r = Result;
165	auto contains = [&result](r val) { return ResultContains(result.result, val); };	438✔
166	auto none_of = [&result](r val) { return ResultNoneOf(result.result, val); };
167	auto add = [](string &str, const string &content) {	5✔
168	if (str.size() > 0) {	5✔
169	str += " ";	×
170	}
171	str += content;	5✔
172	};	5✔
173
174	string operation_done;
175	string operation_failure;
176
177	// For failure case, include which attempted operation failed.
178	if (contains(r::DownloadFailed)) {	87✔
179	operation_failure = "Streaming failed.";	6✔
180	} else if (contains(r::InstallFailed)) {	81✔
181	operation_failure = "Installation failed.";	8✔
182	} else if (contains(r::CommitFailed)) {	73✔
183	operation_failure = "Committing failed.";	6✔
184	}
185
186	// For done case, include which operation succeded.
187	if (contains(r::Committed) and none_of(r::Installed)) {	87✔
188	operation_done = "Committed.";	6✔
189	} else if (contains(r::Installed) and none_of(r::Committed)) {	81✔
190	operation_done =
191	"Installed, but not committed.\n"
192	"Use 'commit' to update, or 'rollback' to roll back the update.";	17✔
193	} else if (contains(r::Downloaded) and none_of(r::Installed)) {	64✔
194	operation_done = "Streamed to storage, but not installed/enabled.";	9✔
195	} else if (contains(r::Installed \| r::Committed)) {	55✔
196	operation_done = "Installed and committed.";	29✔
197	} else if (contains(r::NoUpdateInProgress)) {	26✔
198	operation_done = "No update in progress.";	2✔
199	} else if (contains(r::Cleaned) and none_of(~r::Cleaned)) {	24✔
200	// Only include this message if it was the only thing done.
201	operation_done = "Cleaned up.";	2✔
202	}
203
204	// Pick which one of the done/failure cases to use. If the failure happened after the
205	// commit, we pick the done case, since the operation was still completed.
206	string &operation = (contains(r::Failed) and none_of(r::FailedInPostCommit \| r::CleanupFailed))	24✔
207	? operation_failure
208	: operation_done;	87✔
209
210	string prefix;
211	string additional;
212
213	if (contains(r::AutoCommitWanted) and contains(r::Installed)	33✔
214	and (contains(r::Committed) or contains(r::Failed))) {	120✔
215	prefix = "Update Module doesn't support rollback. Committing immediately.";	32✔
216	}
217
218	if (contains(r::RollbackFailed)) {	87✔
219	additional =
220	"Rollback failed. "
221	"System may be in an inconsistent state.";	7✔
222	} else if (contains(r::NoRollback)) {	80✔
223	additional =
224	"Update Module does not support rollback. "
225	"System may be in an inconsistent state.";	5✔
226	} else if (contains(r::NoRollbackNecessary)) {	75✔
227	additional = "System not modified.";	7✔
228	} else if (contains(r::RolledBack)) {	68✔
229	additional = "Rolled back.";	10✔
230	}
231
232	if (contains(r::FailedInPostCommit)) {	87✔
233	add(additional, "One or more post-commit steps failed.");	4✔
234	}
235	if (contains(r::CleanupFailed)) {	87✔
236	add(additional, "Cleanup failed.");	2✔
237	}
238
239	if (contains(r::RebootRequired)) {	87✔
240	add(additional, "At least one payload requested a reboot of the device it updated.");	4✔
241	if (result.err == error::NoError) {	2✔
242	result.err = context::MakeError(context::RebootRequiredError, "Reboot required");	4✔
243	}
244	}
245
246	if (prefix.size() > 0) {	87✔
247	cout << prefix << endl;	32✔
248	}
249	if (operation.size() > 0) {	87✔
250	cout << operation << endl;	70✔
251	}
252	if (additional.size() > 0) {	87✔
253	cout << additional << endl;	34✔
254	}
255
256	return result.err;	174✔
257	}
258
259	error::Error InstallAction::Execute(context::MenderContext &main_context) {	60✔
260	error::Error err = MaybeInstallBootstrapArtifact(main_context);	60✔
261	if (err != error::NoError) {	60✔
262	return err;
263	}
264	events::EventLoop loop;
265	standalone::Context ctx {main_context, loop};	120✔
266	ctx.stop_before = std::move(stop_before_);	60✔
267	auto result = standalone::Install(ctx, src_);	60✔
268	err = ResultHandler(result);	120✔
269	if (!reboot_exit_code_	60✔
270	&& err.code == context::MakeError(context::RebootRequiredError, "").code) {	236✔
271	// If reboot exit code isn't requested, then this type of error should be treated as
272	// plain success.
273	err = error::NoError;	1✔
274	}
275	return err;
276	}
277
278	error::Error ResumeAction::Execute(context::MenderContext &main_context) {	13✔
279	events::EventLoop loop;
280	standalone::Context ctx {main_context, loop};	26✔
281	ctx.stop_before = std::move(stop_before_);	13✔
282
283	auto result = standalone::Resume(ctx);	13✔
284	auto err = ResultHandler(result);	13✔
285
286	if (!reboot_exit_code_	13✔
287	&& err.code == context::MakeError(context::RebootRequiredError, "").code) {	52✔
288	// If reboot exit code isn't requested, then this type of error should be treated as
289	// plain success.
UNCOV 290	err = error::NoError;	×
291	}
292	return err;	13✔
293	}
294
295	error::Error CommitAction::Execute(context::MenderContext &main_context) {	6✔
296	events::EventLoop loop;
297	standalone::Context ctx {main_context, loop};	12✔
298	ctx.stop_before = std::move(stop_before_);	6✔
299	auto result = standalone::Commit(ctx);	6✔
300	return ResultHandler(result);	18✔
301	}
302
303	error::Error RollbackAction::Execute(context::MenderContext &main_context) {	8✔
304	events::EventLoop loop;
305	standalone::Context ctx {main_context, loop};	16✔
306	ctx.stop_before = std::move(stop_before_);	8✔
307	auto result = standalone::Rollback(ctx);	8✔
308	return ResultHandler(result);	24✔
309	}
310
UNCOV 311	error::Error DaemonAction::Execute(context::MenderContext &main_context) {	×
312	events::EventLoop event_loop;
313	daemon::Context ctx(main_context, event_loop);	×
314
315	#if not defined(MENDER_USE_DBUS) and defined(MENDER_EMBED_MENDER_AUTH)
316	// Passphrase is not currently supported when launching from mender-update cli.
317	auto key_store = mender::auth::cli::KeystoreFromConfig(ctx.mender_context.GetConfig(), "");
318	ctx.authenticator.SetCryptoArgs(
319	{key_store->KeyName(), key_store->PassPhrase(), key_store->SSLEngine()});
320	#endif
321
322	daemon::StateMachine state_machine(ctx, event_loop);	×
UNCOV 323	state_machine.LoadStateFromDb();	×
324	error::Error err = MaybeInstallBootstrapArtifact(main_context);	×
UNCOV 325	if (err != error::NoError) {	×
UNCOV 326	return err;	×
327	}
328
329	event_loop.Post([]() {	×
330	log::Info("The update client daemon is now ready to handle incoming deployments");	×
331	});	×
332
UNCOV 333	return state_machine.Run();	×
334	}
335
336	static expected::ExpectedString GetPID() {	×
UNCOV 337	processes::Process proc({"systemctl", "show", "--property=MainPID", "mender-updated"});	×
338	auto exp_line_data = proc.GenerateLineData();	×
339	if (!exp_line_data) {	×
340	return expected::unexpected(	×
341	exp_line_data.error().WithContext("Failed to get the MainPID from systemctl"));	×
342	}
343	if (exp_line_data.value().size() < 1) {	×
UNCOV 344	return expected::unexpected(error::Error(	×
345	make_error_condition(errc::message_size), "No output received from systemctl"));	×
346	}
347	const string prefix {"MainPID="};	×
UNCOV 348	const string line = exp_line_data.value().at(0);	×
349	auto split_index = line.find(prefix);	×
350	if (split_index == string::npos) {	×
351	return expected::unexpected(error::Error(	×
352	make_error_condition(errc::no_message), "No output received from systemctl"));	×
353	}
UNCOV 354	if (split_index != 0) {	×
355	return expected::unexpected(error::Error(	×
UNCOV 356	make_error_condition(errc::bad_message), "Unexpected output from systemctl"));	×
357	}
358	const string PID = line.substr(split_index + prefix.size(), line.size());	×
359	if (PID == "" or PID == "0") {	×
360	return expected::unexpected(error::Error(	×
361	make_error_condition(errc::no_message),	×
362	"No PID found for mender-updated. The service is not running"));	×
363	}
364	return PID;	×
365	}
366
UNCOV 367	static error::Error SendSignal(const string &signal, const string &pid) {	×
UNCOV 368	const vector<string> command {"kill", "-" + signal, pid};	×
369	const string command_string = common::JoinStrings(command, " ");	×
370	processes::Process proc(command);	×
371	auto err = proc.Start();	×
372	if (err != error::NoError) {	×
UNCOV 373	return err.WithContext("Command '" + command_string + "'");	×
374	}
375	return proc.Wait().WithContext("Command '" + command_string + "'");	×
376	}
377
378	error::Error SendInventoryAction::Execute(context::MenderContext &main_context) {	×
379	auto pid = GetPID();	×
380	if (!pid) {	×
381	return pid.error().WithContext("Failed to force an inventory update");	×
382	}
383
UNCOV 384	return SendSignal("SIGUSR2", pid.value()).WithContext("Failed to force an inventory update");	×
385	}
386
UNCOV 387	error::Error CheckUpdateAction::Execute(context::MenderContext &main_context) {	×
UNCOV 388	auto pid = GetPID();	×
UNCOV 389	if (!pid) {	×
UNCOV 390	return pid.error().WithContext("Failed to force an update check");	×
391	}
UNCOV 392	return SendSignal("SIGUSR1", pid.value()).WithContext("Failed to force an update check");	×
393	}
394
395	} // namespace cli
396	} // namespace update
397	} // namespace mender

mendersoftware / mender / 1499142629

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