1039476627

Committed 17 Oct 2023 10:49AM UTC coverage: 79.701% (-0.6%) from 80.278%

Build # 1039476627

Build Type

push

gitlab-ci

Committed by

oleorhagen

Commit Message

fix(mender-auth): Remember to pass in the needed params

Just add the missing identity script, and private key params.

Ticket: MEN-6671
Changelog: None

Signed-off-by: Ole Petter <ole.orhagen@northern.tech>

Run Details

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

6557 of 8227 relevant lines covered (79.7%)

9764.5 hits per line

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

77.1

/common/conf/conf.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/conf.hpp>

#include <string>
#include <cstdlib>
#include <cerrno>

#include <mender-version.h>

#include <common/error.hpp>
#include <common/expected.hpp>
#include <common/log.hpp>
#include <common/json.hpp>

namespace mender {
namespace common {
namespace conf {

using namespace std;
namespace error = mender::common::error;
namespace expected = mender::common::expected;
namespace log = mender::common::log;
namespace json = mender::common::json;

const string kMenderVersion = MENDER_VERSION;

const ConfigErrorCategoryClass ConfigErrorCategory;

const char *ConfigErrorCategoryClass::name() const noexcept {
        return "ConfigErrorCategory";
}

string ConfigErrorCategoryClass::message(int code) const {
        switch (code) {
        case NoError:
                return "Success";
        case InvalidOptionsError:
                return "Invalid options given";
        }
        assert(false);
        return "Unknown";
}

error::Error MakeError(ConfigErrorCode code, const string &msg) {
        return error::Error(error_condition(code, ConfigErrorCategory), msg);
}


string GetEnv(const string &var_name, const string &default_value) {
        const char *value = getenv(var_name.c_str());
        if (value == nullptr) {
                return string(default_value);
        } else {
                return string(value);
        }
}

ExpectedOptionValue CmdlineOptionsIterator::Next() {
        string option = "";
        string value = "";

        if (start_ + pos_ >= end_) {
                return ExpectedOptionValue({"", ""});
        }

        if (past_double_dash_) {
                OptionValue opt_val {"", start_[pos_]};
                pos_++;
                return ExpectedOptionValue(opt_val);
        }

        if (start_[pos_] == "--") {
                past_double_dash_ = true;
                pos_++;
                return ExpectedOptionValue({"--", ""});
        }

        if (start_[pos_][0] == '-') {
                auto eq_idx = start_[pos_].find('=');
                if (eq_idx != string::npos) {
                        option = start_[pos_].substr(0, eq_idx);
                        value = start_[pos_].substr(eq_idx + 1, start_[pos_].size() - eq_idx - 1);
                        pos_++;
                } else {
                        option = start_[pos_];
                        pos_++;
                }

                if (opts_with_value_.count(option) != 0) {
                        // option with value
                        if ((value == "") && ((start_ + pos_ >= end_) || (start_[pos_][0] == '-'))) {
                                // the next item is not a value
                                error::Error err = MakeError(
                                        ConfigErrorCode::InvalidOptionsError, "Option " + option + " missing value");
                                return ExpectedOptionValue(expected::unexpected(err));
                        } else if (value == "") {
                                // only assign the next item as value if there was no value
                                // specified as '--opt=value' (parsed above)
                                value = start_[pos_];
                                pos_++;
                        }
                } else if (opts_wo_value_.count(option) == 0) {
                        // unknown option
                        error::Error err = MakeError(
                                ConfigErrorCode::InvalidOptionsError, "Unrecognized option '" + option + "'");
                        return ExpectedOptionValue(expected::unexpected(err));
                } else if (value != "") {
                        // option without a value, yet, there was a value specified as '--opt=value' (parsed
                        // above)
                        error::Error err = MakeError(
                                ConfigErrorCode::InvalidOptionsError,
                                "Option " + option + " doesn't expect a value");
                        return ExpectedOptionValue(expected::unexpected(err));
                }
        } else {
                switch (mode_) {
                case ArgumentsMode::AcceptBareArguments:
                        value = start_[pos_];
                        pos_++;
                        break;
                case ArgumentsMode::RejectBareArguments:
                        return expected::unexpected(MakeError(
                                ConfigErrorCode::InvalidOptionsError,
                                "Unexpected argument '" + start_[pos_] + "'"));
                case ArgumentsMode::StopAtBareArguments:
                        return ExpectedOptionValue({"", ""});
                }
        }

        return ExpectedOptionValue({std::move(option), std::move(value)});
}

expected::ExpectedSize MenderConfig::ProcessCmdlineArgs(
        vector<string>::const_iterator start, vector<string>::const_iterator end) {
        bool explicit_config_path = false;
        bool explicit_fallback_config_path = false;
        string log_file = "";
        string log_level;

        CmdlineOptionsIterator opts_iter(
                start,
                end,
                {"--config",
                 "-c",
                 "--fallback-config",
                 "-b",
                 "--data",
                 "-d",
                 "--log-file",
                 "-L",
                 "--log-level",
                 "-l"},
                {"--version", "-v"});
        opts_iter.SetArgumentsMode(ArgumentsMode::StopAtBareArguments);
        auto ex_opt_val = opts_iter.Next();
        int arg_count = 0;
        bool version_arg = false;
        while (ex_opt_val && ((ex_opt_val.value().option != "") || (ex_opt_val.value().value != ""))) {
                arg_count++;
                auto opt_val = ex_opt_val.value();
                if ((opt_val.option == "--config") || (opt_val.option == "-c")) {
                        paths.SetConfFile(opt_val.value);
                        explicit_config_path = true;
                } else if ((opt_val.option == "--fallback-config") || (opt_val.option == "-b")) {
                        paths.SetFallbackConfFile(opt_val.value);
                        explicit_fallback_config_path = true;
                } else if ((opt_val.option == "--data") || (opt_val.option == "-d")) {
                        paths.SetDataStore(opt_val.value);
                } else if ((opt_val.option == "--log-file") || (opt_val.option == "-L")) {
                        log_file = opt_val.value;
                } else if ((opt_val.option == "--log-level") || (opt_val.option == "-l")) {
                        log_level = opt_val.value;
                } else if ((opt_val.option == "--version") || (opt_val.option == "-v")) {
                        version_arg = true;
                }
                ex_opt_val = opts_iter.Next();
        }
        if (!ex_opt_val) {
                return expected::unexpected(ex_opt_val.error());
        }

        if (version_arg) {
                if (arg_count > 1 || opts_iter.GetPos() < static_cast<size_t>(end - start)) {
                        return expected::unexpected(error::Error(
                                make_error_condition(errc::invalid_argument),
                                "--version can not be combined with other commands and arguments"));
                } else {
                        cout << kMenderVersion << endl;
                        return expected::unexpected(error::MakeError(error::ExitWithSuccessError, ""));
                }
        }

        if (log_file != "") {
                auto err = log::SetupFileLogging(log_file, true);
                if (error::NoError != err) {
                        return expected::unexpected(err);
                }
        }

        SetLevel(log::kDefaultLogLevel);

        if (log_level != "") {
                auto ex_log_level = log::StringToLogLevel(log_level);
                if (!ex_log_level) {
                        return expected::unexpected(ex_log_level.error());
                }
                SetLevel(ex_log_level.value());
        }

        auto err = LoadConfigFile_(paths.GetConfFile(), explicit_config_path);
        if (error::NoError != err) {
                this->Reset();
                return expected::unexpected(err);
        }

        err = LoadConfigFile_(paths.GetFallbackConfFile(), explicit_fallback_config_path);
        if (error::NoError != err) {
                this->Reset();
                return expected::unexpected(err);
        }

        if (this->update_log_path != "") {
                paths.SetUpdateLogPath(this->update_log_path);
        }

        if (log_level == "" && this->daemon_log_level != "") {
                auto ex_log_level = log::StringToLogLevel(this->daemon_log_level);
                if (!ex_log_level) {
                        return expected::unexpected(ex_log_level.error());
                }
                SetLevel(ex_log_level.value());
        }

        return opts_iter.GetPos();
}

error::Error MenderConfig::LoadConfigFile_(const string &path, bool required) {
        auto ret = this->LoadFile(path);
        if (!ret) {
                if (required) {
                        // any failure when a file is required (e.g. path was given explicitly) means an error
                        log::Error("Failed to load config from '" + path + "': " + ret.error().message);
                        return ret.error();
                } else if (ret.error().IsErrno(ENOENT)) {
                        // File doesn't exist, OK for non-required
                        log::Debug("Failed to load config from '" + path + "': " + ret.error().message);
                        return error::NoError;
                } else {
                        // other errors (parsing errors,...) for default paths should produce warnings
                        log::Warning("Failed to load config from '" + path + "': " + ret.error().message);
                        return error::NoError;
                }
        }
        // else
        auto valid = this->ValidateConfig();
        if (!valid) {
                // validation error is always an error
                log::Error("Failed to validate config from '" + path + "': " + valid.error().message);
                return valid.error();
        }

        return error::NoError;
}

error::Error MenderConfig::LoadDefaults() {
        auto err = LoadConfigFile_(paths.GetFallbackConfFile(), false);
        if (error::NoError != err) {
                this->Reset();
                return err;
        }

        err = LoadConfigFile_(paths.GetConfFile(), false);
        if (error::NoError != err) {
                this->Reset();
                return err;
        }

        return error::NoError;
}

} // namespace conf
} // 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/conf.hpp>
16
17	#include <string>
18	#include <cstdlib>
19	#include <cerrno>
20
21	#include <mender-version.h>
22
23	#include <common/error.hpp>
24	#include <common/expected.hpp>
25	#include <common/log.hpp>
26	#include <common/json.hpp>
27
28	namespace mender {
29	namespace common {
30	namespace conf {
31
32	using namespace std;
33	namespace error = mender::common::error;
34	namespace expected = mender::common::expected;
35	namespace log = mender::common::log;
36	namespace json = mender::common::json;
37
38	const string kMenderVersion = MENDER_VERSION;
39
40	const ConfigErrorCategoryClass ConfigErrorCategory;
41
42	const char *ConfigErrorCategoryClass::name() const noexcept {	×
43	return "ConfigErrorCategory";	×
44	}
45
46	string ConfigErrorCategoryClass::message(int code) const {	10✔
47	switch (code) {	10✔
48	case NoError:
49	return "Success";	×
50	case InvalidOptionsError:
51	return "Invalid options given";	10✔
52	}
53	assert(false);
54	return "Unknown";	×
55	}
56
57	error::Error MakeError(ConfigErrorCode code, const string &msg) {	5✔
58	return error::Error(error_condition(code, ConfigErrorCategory), msg);	15✔
59	}
60
61
62	string GetEnv(const string &var_name, const string &default_value) {	1,069✔
63	const char *value = getenv(var_name.c_str());	1,069✔
64	if (value == nullptr) {	1,069✔
65	return string(default_value);	1,068✔
66	} else {
67	return string(value);	1✔
68	}
69	}
70
71	ExpectedOptionValue CmdlineOptionsIterator::Next() {	392✔
72	string option = "";	392✔
73	string value = "";	392✔
74
75	if (start_ + pos_ >= end_) {	392✔
76	return ExpectedOptionValue({"", ""});	106✔
77	}
78
79	if (past_double_dash_) {	286✔
80	OptionValue opt_val {"", start_[pos_]};	6✔
81	pos_++;	3✔
82	return ExpectedOptionValue(opt_val);	3✔
83	}
84
85	if (start_[pos_] == "--") {	283✔
86	past_double_dash_ = true;	1✔
87	pos_++;	1✔
88	return ExpectedOptionValue({"--", ""});	1✔
89	}
90
91	if (start_[pos_][0] == '-') {	282✔
92	auto eq_idx = start_[pos_].find('=');	125✔
93	if (eq_idx != string::npos) {	125✔
94	option = start_[pos_].substr(0, eq_idx);	3✔
95	value = start_[pos_].substr(eq_idx + 1, start_[pos_].size() - eq_idx - 1);	3✔
96	pos_++;	3✔
97	} else {
98	option = start_[pos_];	122✔
99	pos_++;	122✔
100	}
101
102	if (opts_with_value_.count(option) != 0) {	125✔
103	// option with value
104	if ((value == "") && ((start_ + pos_ >= end_) \|\| (start_[pos_][0] == '-'))) {	111✔
105	// the next item is not a value
106	error::Error err = MakeError(
107	ConfigErrorCode::InvalidOptionsError, "Option " + option + " missing value");	4✔
108	return ExpectedOptionValue(expected::unexpected(err));	4✔
109	} else if (value == "") {	109✔
110	// only assign the next item as value if there was no value
111	// specified as '--opt=value' (parsed above)
112	value = start_[pos_];	107✔
113	pos_++;	107✔
114	}
115	} else if (opts_wo_value_.count(option) == 0) {	14✔
116	// unknown option
117	error::Error err = MakeError(
118	ConfigErrorCode::InvalidOptionsError, "Unrecognized option '" + option + "'");	8✔
119	return ExpectedOptionValue(expected::unexpected(err));	8✔
120	} else if (value != "") {	10✔
121	// option without a value, yet, there was a value specified as '--opt=value' (parsed
122	// above)
123	error::Error err = MakeError(
124	ConfigErrorCode::InvalidOptionsError,
125	"Option " + option + " doesn't expect a value");	2✔
126	return ExpectedOptionValue(expected::unexpected(err));	2✔
127	}
128	} else {
129	switch (mode_) {	157✔
130	case ArgumentsMode::AcceptBareArguments:	50✔
131	value = start_[pos_];
132	pos_++;	50✔
133	break;	50✔
134	case ArgumentsMode::RejectBareArguments:	3✔
135	return expected::unexpected(MakeError(	3✔
136	ConfigErrorCode::InvalidOptionsError,
137	"Unexpected argument '" + start_[pos_] + "'"));	9✔
138	case ArgumentsMode::StopAtBareArguments:
139	return ExpectedOptionValue({"", ""});	104✔
140	}
141	}
142
143	return ExpectedOptionValue({std::move(option), std::move(value)});	168✔
144	}
145
146	expected::ExpectedSize MenderConfig::ProcessCmdlineArgs(	110✔
147	vector<string>::const_iterator start, vector<string>::const_iterator end) {
148	bool explicit_config_path = false;
149	bool explicit_fallback_config_path = false;
150	string log_file = "";	110✔
151	string log_level;
152
153	CmdlineOptionsIterator opts_iter(
154	start,
155	end,
156	{"--config",
157	"-c",
158	"--fallback-config",
159	"-b",
160	"--data",
161	"-d",
162	"--log-file",
163	"-L",
164	"--log-level",
165	"-l"},
166	{"--version", "-v"});	2,090✔
167	opts_iter.SetArgumentsMode(ArgumentsMode::StopAtBareArguments);
168	auto ex_opt_val = opts_iter.Next();	110✔
169	int arg_count = 0;
170	bool version_arg = false;
171	while (ex_opt_val && ((ex_opt_val.value().option != "") \|\| (ex_opt_val.value().value != ""))) {	216✔
172	arg_count++;	106✔
173	auto opt_val = ex_opt_val.value();	106✔
174	if ((opt_val.option == "--config") \|\| (opt_val.option == "-c")) {	106✔
175	paths.SetConfFile(opt_val.value);
176	explicit_config_path = true;
177	} else if ((opt_val.option == "--fallback-config") \|\| (opt_val.option == "-b")) {	103✔
178	paths.SetFallbackConfFile(opt_val.value);
179	explicit_fallback_config_path = true;
180	} else if ((opt_val.option == "--data") \|\| (opt_val.option == "-d")) {	103✔
181	paths.SetDataStore(opt_val.value);	97✔
182	} else if ((opt_val.option == "--log-file") \|\| (opt_val.option == "-L")) {	6✔
183	log_file = opt_val.value;
184	} else if ((opt_val.option == "--log-level") \|\| (opt_val.option == "-l")) {	6✔
185	log_level = opt_val.value;
186	} else if ((opt_val.option == "--version") \|\| (opt_val.option == "-v")) {	4✔
187	version_arg = true;
188	}
189	ex_opt_val = opts_iter.Next();	212✔
190	}
191	if (!ex_opt_val) {	110✔
192	return expected::unexpected(ex_opt_val.error());	×
193	}
194
195	if (version_arg) {	110✔
196	if (arg_count > 1 \|\| opts_iter.GetPos() < static_cast<size_t>(end - start)) {	4✔
197	return expected::unexpected(error::Error(	2✔
198	make_error_condition(errc::invalid_argument),	4✔
199	"--version can not be combined with other commands and arguments"));	6✔
200	} else {
201	cout << kMenderVersion << endl;	2✔
202	return expected::unexpected(error::MakeError(error::ExitWithSuccessError, ""));	6✔
203	}
204	}
205
206	if (log_file != "") {	106✔
207	auto err = log::SetupFileLogging(log_file, true);	×
208	if (error::NoError != err) {	×
209	return expected::unexpected(err);	×
210	}
211	}
212
213	SetLevel(log::kDefaultLogLevel);	106✔
214
215	if (log_level != "") {	106✔
216	auto ex_log_level = log::StringToLogLevel(log_level);	2✔
217	if (!ex_log_level) {	2✔
218	return expected::unexpected(ex_log_level.error());	×
219	}
220	SetLevel(ex_log_level.value());	2✔
221	}
222
223	auto err = LoadConfigFile_(paths.GetConfFile(), explicit_config_path);	106✔
224	if (error::NoError != err) {	106✔
225	this->Reset();	×
226	return expected::unexpected(err);	×
227	}
228
229	err = LoadConfigFile_(paths.GetFallbackConfFile(), explicit_fallback_config_path);	212✔
230	if (error::NoError != err) {	106✔
231	this->Reset();	×
232	return expected::unexpected(err);	×
233	}
234
235	if (this->update_log_path != "") {	106✔
236	paths.SetUpdateLogPath(this->update_log_path);
237	}
238
239	if (log_level == "" && this->daemon_log_level != "") {	106✔
240	auto ex_log_level = log::StringToLogLevel(this->daemon_log_level);	1✔
241	if (!ex_log_level) {	1✔
242	return expected::unexpected(ex_log_level.error());	×
243	}
244	SetLevel(ex_log_level.value());	1✔
245	}
246
247	return opts_iter.GetPos();
248	}
249
250	error::Error MenderConfig::LoadConfigFile_(const string &path, bool required) {	212✔
251	auto ret = this->LoadFile(path);	212✔
252	if (!ret) {	212✔
253	if (required) {	209✔
254	// any failure when a file is required (e.g. path was given explicitly) means an error
255	log::Error("Failed to load config from '" + path + "': " + ret.error().message);	×
256	return ret.error();	×
257	} else if (ret.error().IsErrno(ENOENT)) {	209✔
258	// File doesn't exist, OK for non-required
259	log::Debug("Failed to load config from '" + path + "': " + ret.error().message);	418✔
260	return error::NoError;	209✔
261	} else {
262	// other errors (parsing errors,...) for default paths should produce warnings
263	log::Warning("Failed to load config from '" + path + "': " + ret.error().message);	×
264	return error::NoError;	×
265	}
266	}
267	// else
268	auto valid = this->ValidateConfig();	3✔
269	if (!valid) {	3✔
270	// validation error is always an error
271	log::Error("Failed to validate config from '" + path + "': " + valid.error().message);	×
272	return valid.error();	×
273	}
274
275	return error::NoError;	3✔
276	}
277
278	error::Error MenderConfig::LoadDefaults() {	×
279	auto err = LoadConfigFile_(paths.GetFallbackConfFile(), false);	×
280	if (error::NoError != err) {	×
281	this->Reset();	×
282	return err;	×
283	}
284
285	err = LoadConfigFile_(paths.GetConfFile(), false);	×
286	if (error::NoError != err) {	×
287	this->Reset();	×
288	return err;	×
289	}
290
291	return error::NoError;	×
292	}
293
294	} // namespace conf
295	} // namespace common
296	} // namespace mender

mendersoftware / mender / 1039476627

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