1012473002

Committed 21 Sep 2023 02:17PM UTC coverage: 78.107% (-0.3%) from 78.44%

Build # 1012473002

Build Type

push

gitlab-ci

Committed by

lluiscampos

Commit Message

chore: log stdout output on errors when parsing UM yes/no commands

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

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

6468 of 8281 relevant lines covered (78.11%)

11106.28 hits per line

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

87.12

/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/key_value_database.hpp>
#include <common/log.hpp>
#include <common/path.hpp>

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

namespace mender {
namespace update {
namespace cli {

namespace conf = mender::common::conf;
namespace daemon = mender::update::daemon;
namespace database = mender::common::key_value_database;
namespace error = mender::common::error;
namespace events = mender::common::events;
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");
        auto result = standalone::Install(
                main_context, bootstrap_artifact_path, artifact::config::Signature::Skip);

        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) {
        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) {
        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) {
        switch (result.result) {
        case standalone::Result::InstalledAndCommitted:
        case standalone::Result::Committed:
        case standalone::Result::Installed:
        case standalone::Result::RolledBack:
                // There should not be any error for these.
                assert(result.err == error::NoError);
                break;
        case standalone::Result::InstalledAndCommittedRebootRequired:
        case standalone::Result::InstalledRebootRequired:
                if (result.err == error::NoError) {
                        result.err = context::MakeError(context::RebootRequiredError, "Reboot required");
                }
                break;
        default:
                // All other states, make sure they have an error.
                if (result.err != error::NoError) {
                        log::Error(result.err.String());
                } else {
                        result.err = error::MakeError(error::ExitWithFailureError, "");
                }
                break;
        }

        switch (result.result) {
        case standalone::Result::InstalledAndCommitted:
        case standalone::Result::InstalledAndCommittedRebootRequired:
                cout << "Installed and committed." << endl;
                break;
        case standalone::Result::Committed:
                cout << "Committed." << endl;
                break;
        case standalone::Result::Installed:
        case standalone::Result::InstalledRebootRequired:
                cout << "Installed, but not committed." << endl;
                cout << "Use 'commit' to update, or 'rollback' to roll back the update." << endl;
                break;
        case standalone::Result::InstalledButFailedInPostCommit:
                cout << "Installed, but one or more post-commit steps failed." << endl;
                break;
        case standalone::Result::NoUpdateInProgress:
                cout << "No update in progress." << endl;
                break;
        case standalone::Result::FailedNothingDone:
                cout << "Installation failed. System not modified." << endl;
                break;
        case standalone::Result::RolledBack:
                cout << "Rolled back." << endl;
                break;
        case standalone::Result::NoRollback:
                cout << "Update Module does not support rollback." << endl;
                break;
        case standalone::Result::RollbackFailed:
                cout << "Rollback failed. System may be in an inconsistent state." << endl;
                break;
        case standalone::Result::FailedAndRolledBack:
                cout << "Installation failed. Rolled back modifications." << endl;
                break;
        case standalone::Result::FailedAndNoRollback:
                cout
                        << "Installation failed, and Update Module does not support rollback. System may be in an inconsistent state."
                        << endl;
                break;
        case standalone::Result::FailedAndRollbackFailed:
                cout
                        << "Installation failed, and rollback also failed. System may be in an inconsistent state."
                        << endl;
                break;
        }

        switch (result.result) {
        case standalone::Result::InstalledRebootRequired:
        case standalone::Result::InstalledAndCommittedRebootRequired:
                cout << "At least one payload requested a reboot of the device it updated." << endl;
                break;
        default:
                break;
        }

        return result.err;
}

error::Error InstallAction::Execute(context::MenderContext &main_context) {
        error::Error err = MaybeInstallBootstrapArtifact(main_context);
        if (err != error::NoError) {
                return err;
        }
        auto result = standalone::Install(main_context, 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 CommitAction::Execute(context::MenderContext &main_context) {
        auto result = standalone::Commit(main_context);
        return ResultHandler(result);
}

error::Error RollbackAction::Execute(context::MenderContext &main_context) {
        auto result = standalone::Rollback(main_context);
        return ResultHandler(result);
}

error::Error DaemonAction::Execute(context::MenderContext &main_context) {
        events::EventLoop event_loop;
        daemon::Context ctx(main_context, event_loop);
        daemon::StateMachine state_machine(ctx, event_loop);
        state_machine.LoadStateFromDb();
        error::Error err = MaybeInstallBootstrapArtifact(main_context);
        if (err != error::NoError) {
                return err;
        }
        return state_machine.Run();
}

} // 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/key_value_database.hpp>
27	#include <common/log.hpp>
28	#include <common/path.hpp>
29
30	#include <mender-update/cli/cli.hpp>
31	#include <mender-update/daemon.hpp>
32	#include <mender-update/standalone.hpp>
33
34	namespace mender {
35	namespace update {
36	namespace cli {
37
38	namespace conf = mender::common::conf;
39	namespace daemon = mender::update::daemon;
40	namespace database = mender::common::key_value_database;
41	namespace error = mender::common::error;
42	namespace events = mender::common::events;
43	namespace kv_db = mender::common::key_value_database;
44	namespace log = mender::common::log;
45	namespace path = mender::common::path;
46	namespace standalone = mender::update::standalone;
47
48	static error::Error DoMaybeInstallBootstrapArtifact(context::MenderContext &main_context) {	47✔
49	const string bootstrap_artifact_path {
50	main_context.GetConfig().paths.GetBootstrapArtifactFile()};	94✔
51	// Check if the DB is populated - then install conditionally
52	auto &db = main_context.GetMenderStoreDB();	47✔
53	auto exp_key = db.Read(main_context.artifact_name_key);	94✔
54	if (exp_key) {	47✔
55	// Key exists. Do nothing
56	return error::NoError;	13✔
57	}
58	error::Error err = exp_key.error();	68✔
59	if (err.code != kv_db::MakeError(kv_db::KeyError, "Key Not found").code) {	34✔
60	return err;	×
61	}
62
63	// Key does not exist, install the bootstrap artifact if it exists
64	if (!path::FileExists(bootstrap_artifact_path)) {	34✔
65	log::Debug("No Bootstrap Artifact found at: " + bootstrap_artifact_path);	33✔
66	error::Error err =
67	db.Write(main_context.artifact_name_key, common::ByteVectorFromString("unknown"));	66✔
68	if (err != error::NoError) {	33✔
69	return err;	×
70	}
71	return error::NoError;	33✔
72	}
73	log::Info("Installing the bootstrap Artifact");	1✔
74	auto result = standalone::Install(
75	main_context, bootstrap_artifact_path, artifact::config::Signature::Skip);	2✔
76
77	if (result.err != error::NoError) {	1✔
78	error::Error err =
79	db.Write(main_context.artifact_name_key, common::ByteVectorFromString("unknown"));	×
80	return result.err.FollowedBy(err).WithContext("Failed to install the bootstrap Artifact");	×
81	}
82	return error::NoError;	1✔
83	}
84
85	error::Error MaybeInstallBootstrapArtifact(context::MenderContext &main_context) {	47✔
86	const string bootstrap_artifact_path {
87	main_context.GetConfig().paths.GetBootstrapArtifactFile()};	94✔
88	error::Error err = DoMaybeInstallBootstrapArtifact(main_context);	94✔
89
90	// Unconditionally delete the bootstrap Artifact
91	if (path::FileExists(bootstrap_artifact_path)) {	47✔
92	error::Error delete_err = path::FileDelete(bootstrap_artifact_path);	1✔
93	if (delete_err != error::NoError) {	1✔
94	return err.FollowedBy(
95	delete_err.WithContext("Failed to delete the bootstrap Artifact"));	×
96	}
97	}
98	return err;	47✔
99	}
100
101	error::Error ShowArtifactAction::Execute(context::MenderContext &main_context) {	2✔
102	auto exp_provides = main_context.LoadProvides();	4✔
103	if (!exp_provides) {	2✔
104	return exp_provides.error();	×
105	}
106
107	auto &provides = exp_provides.value();	2✔
108	if (provides.count("artifact_name") == 0 \|\| provides["artifact_name"] == "") {	5✔
109	cout << "Unknown" << endl;	1✔
110	} else {
111	cout << provides["artifact_name"] << endl;	1✔
112	}
113	return error::NoError;	2✔
114	}
115
116	error::Error ShowProvidesAction::Execute(context::MenderContext &main_context) {	32✔
117	auto exp_provides = main_context.LoadProvides();	64✔
118	if (!exp_provides) {	32✔
119	return exp_provides.error();	×
120	}
121
122	auto &provides = exp_provides.value();	32✔
123	for (const auto &elem : provides) {	104✔
124	cout << elem.first << "=" << elem.second << endl;	72✔
125	}
126
127	return error::NoError;	32✔
128	}
129
130	static error::Error ResultHandler(standalone::ResultAndError result) {	54✔
131	switch (result.result) {	54✔
132	case standalone::Result::InstalledAndCommitted:	32✔
133	case standalone::Result::Committed:
134	case standalone::Result::Installed:
135	case standalone::Result::RolledBack:
136	// There should not be any error for these.
137	assert(result.err == error::NoError);	32✔
138	break;	32✔
139	case standalone::Result::InstalledAndCommittedRebootRequired:	2✔
140	case standalone::Result::InstalledRebootRequired:
141	if (result.err == error::NoError) {	2✔
142	result.err = context::MakeError(context::RebootRequiredError, "Reboot required");	2✔
143	}
144	break;	2✔
145	default:	20✔
146	// All other states, make sure they have an error.
147	if (result.err != error::NoError) {	20✔
148	log::Error(result.err.String());	14✔
149	} else {
150	result.err = error::MakeError(error::ExitWithFailureError, "");	6✔
151	}
152	break;	20✔
153	}
154
155	switch (result.result) {	54✔
156	case standalone::Result::InstalledAndCommitted:	19✔
157	case standalone::Result::InstalledAndCommittedRebootRequired:
158	cout << "Installed and committed." << endl;	19✔
159	break;	19✔
160	case standalone::Result::Committed:	3✔
161	cout << "Committed." << endl;	3✔
162	break;	3✔
163	case standalone::Result::Installed:	9✔
164	case standalone::Result::InstalledRebootRequired:
165	cout << "Installed, but not committed." << endl;	9✔
166	cout << "Use 'commit' to update, or 'rollback' to roll back the update." << endl;	9✔
167	break;	9✔
168	case standalone::Result::InstalledButFailedInPostCommit:	2✔
169	cout << "Installed, but one or more post-commit steps failed." << endl;	2✔
170	break;	2✔
171	case standalone::Result::NoUpdateInProgress:	2✔
172	cout << "No update in progress." << endl;	2✔
173	break;	2✔
174	case standalone::Result::FailedNothingDone:	5✔
175	cout << "Installation failed. System not modified." << endl;	5✔
176	break;	5✔
177	case standalone::Result::RolledBack:	3✔
178	cout << "Rolled back." << endl;	3✔
179	break;	3✔
180	case standalone::Result::NoRollback:	1✔
181	cout << "Update Module does not support rollback." << endl;	1✔
182	break;	1✔
183	case standalone::Result::RollbackFailed:	1✔
184	cout << "Rollback failed. System may be in an inconsistent state." << endl;	1✔
185	break;	1✔
186	case standalone::Result::FailedAndRolledBack:	1✔
187	cout << "Installation failed. Rolled back modifications." << endl;	1✔
188	break;	1✔
189	case standalone::Result::FailedAndNoRollback:	4✔
190	cout
191	<< "Installation failed, and Update Module does not support rollback. System may be in an inconsistent state."	4✔
192	<< endl;	4✔
193	break;	4✔
194	case standalone::Result::FailedAndRollbackFailed:	4✔
195	cout
196	<< "Installation failed, and rollback also failed. System may be in an inconsistent state."	4✔
197	<< endl;	4✔
198	break;	4✔
199	}
200
201	switch (result.result) {	54✔
202	case standalone::Result::InstalledRebootRequired:	2✔
203	case standalone::Result::InstalledAndCommittedRebootRequired:
204	cout << "At least one payload requested a reboot of the device it updated." << endl;	2✔
205	break;	2✔
206	default:	52✔
207	break;	52✔
208	}
209
210	return result.err;	54✔
211	}
212
213	error::Error InstallAction::Execute(context::MenderContext &main_context) {	44✔
214	error::Error err = MaybeInstallBootstrapArtifact(main_context);	44✔
215	if (err != error::NoError) {	44✔
216	return err;	×
217	}
218	auto result = standalone::Install(main_context, src_);	88✔
219	err = ResultHandler(result);	44✔
220	if (!reboot_exit_code_	44✔
221	&& err.code == context::MakeError(context::RebootRequiredError, "").code) {	44✔
222	// If reboot exit code isn't requested, then this type of error should be treated as
223	// plain success.
224	err = error::NoError;	1✔
225	}
226	return err;	44✔
227	}
228
229	error::Error CommitAction::Execute(context::MenderContext &main_context) {	4✔
230	auto result = standalone::Commit(main_context);	4✔
231	return ResultHandler(result);	8✔
232	}
233
234	error::Error RollbackAction::Execute(context::MenderContext &main_context) {	6✔
235	auto result = standalone::Rollback(main_context);	6✔
236	return ResultHandler(result);	12✔
237	}
238
239	error::Error DaemonAction::Execute(context::MenderContext &main_context) {	×
240	events::EventLoop event_loop;	×
241	daemon::Context ctx(main_context, event_loop);	×
242	daemon::StateMachine state_machine(ctx, event_loop);	×
243	state_machine.LoadStateFromDb();	×
244	error::Error err = MaybeInstallBootstrapArtifact(main_context);	×
245	if (err != error::NoError) {	×
246	return err;	×
247	}
248	return state_machine.Run();	×
249	}
250
251	} // namespace cli
252	} // namespace update
253	} // namespace mender

mendersoftware / mender / 1012473002

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