1583599051

Committed 11 Dec 2024 09:04AM UTC coverage: 76.259% (-0.2%) from 76.43%

Build # 1583599051

Build Type

push

gitlab-ci

Committed by

vpodzime

Commit Message

fix: Cancel the previous request before scheduling a new one in HTTP resumer

The `http::Client()` class is designed to always have only one
HTTP request in progress. Thus, before scheduling a new request
using the same `http::Client` instance, cancel the previous
request to make sure everything is properly reset for the new
one.

Ticket: MEN-7810
Changelog: Fix download resuming to reset the HTTP state and
avoid repeatedly hitting the same error in case of a bad state

Signed-off-by: Vratislav Podzimek <vratislav.podzimek@northern.tech>

Run Details

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

55 existing lines in 11 files now uncovered.

7375 of 9671 relevant lines covered (76.26%)

11182.97 hits per line

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

0.0

/src/common/yaml.hpp

// Copyright 2024 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.

#ifndef MENDER_COMMON_YAML_HPP
#define MENDER_COMMON_YAML_HPP

#include <common/config.h>

#include <map>
#include <string>
#include <unordered_map>

#include <common/common.hpp>
#include <common/error.hpp>
#include <common/expected.hpp>
#include <common/io.hpp>

#ifdef MENDER_USE_YAML_CPP
#include <yaml-cpp/yaml.h>
#endif

namespace mender {
namespace common {
namespace yaml {

using namespace std;

namespace error = mender::common::error;
namespace io = mender::common::io;
namespace common = mender::common;

enum YamlErrorCode {
        NoError = 0,
        ParseError,
        KeyError,
        IndexError,
        TypeError,
};

class YamlErrorCategoryClass : public error_category {
public:
        const char *name() const noexcept override;
        string message(int code) const override;
};
extern const YamlErrorCategoryClass YamlErrorCategory;

error::Error MakeError(YamlErrorCode code, const string &msg);

using ExpectedString = mender::common::expected::ExpectedString;
using ExpectedInt64 = mender::common::expected::ExpectedInt64;
using ExpectedDouble = mender::common::expected::ExpectedDouble;
using ExpectedBool = mender::common::expected::ExpectedBool;
using ExpectedSize = mender::common::expected::ExpectedSize;

class Yaml;
using ExpectedYaml = expected::expected<Yaml, error::Error>;
using ChildrenMap = map<string, Yaml>;
using ExpectedChildrenMap = expected::expected<ChildrenMap, error::Error>;

class Yaml {
public:
        Yaml() = default;

        Yaml(const Yaml &) = default;
        Yaml &operator=(const Yaml &) = default;

        Yaml(Yaml &&) = default;
        Yaml &operator=(Yaml &&) = default;

        string Dump(const int indent = 2) const;

        ExpectedYaml Get(const char *child_key) const;
        ExpectedYaml operator[](const char *child_key) const {
                return this->Get(child_key);
        }
        ExpectedYaml Get(const string &child_key) const {
                return this->Get(child_key.data());
        }
        ExpectedYaml operator[](const string &child_key) const {
                return this->Get(child_key.data());
        }
        ExpectedYaml Get(const size_t idx) const;
        ExpectedYaml operator[](const size_t idx) const {
                return this->Get(idx);
        }

        ExpectedChildrenMap GetChildren() const;

        bool IsObject() const;
        bool IsArray() const;
        bool IsString() const;
        bool IsInt64() const;
        bool IsNumber() const;
        bool IsDouble() const;
        bool IsBool() const;
        bool IsNull() const;

        // Defined in cpp file as specialized templates.
        template <typename T>
        typename enable_if<
                not is_integral<T>::value or is_same<T, int64_t>::value or is_same<T, bool>::value,
                expected::expected<T, error::Error>>::type
        Get() const;

        // Use this as a catch-all for all integral types besides int64_t and bool. It then
        // automates the process of checking whether it fits in the requested data type.
        template <typename T>
        typename enable_if<
                is_integral<T>::value and not is_same<T, int64_t>::value and not is_same<T, bool>::value,
                expected::expected<T, error::Error>>::type
        Get() const {
                auto num = Get<int64_t>();
                if (!num) {
                        return expected::unexpected(num.error());
                }
                bool fits = true;
                if (is_signed<T>()) {
                        if (num.value() < numeric_limits<T>::lowest()
                                or num.value() > numeric_limits<T>::max()) {
                                fits = false;
                        }
                } else {
                        if (static_cast<unsigned long long>(num.value()) > numeric_limits<T>::max()) {
                                fits = false;
                        }
                }
                if (not fits) {
                        return expected::unexpected(error::Error(
                                make_error_condition(errc::result_out_of_range),
                                "Json::Get(): Number " + to_string(num.value())
                                        + " does not fit in requested data type"));
                }
                return static_cast<T>(num.value());
        }

        ExpectedSize GetArraySize() const;

        string GetType() const;
        friend std::ostream &operator<<(std::ostream &os, const Yaml &y) {
#ifdef MENDER_USE_YAML_CPP
                os << y.n_yaml;
#endif
                return os;
        }

        friend ExpectedYaml LoadFromFile(string file_path);
        friend ExpectedYaml Load(string yaml_str);
        friend ExpectedYaml Load(istream &str);
        friend ExpectedYaml Load(io::Reader &reader);

public:
#ifdef MENDER_USE_YAML_CPP
        YAML::Node n_yaml;
        Yaml(YAML::Node n_yaml) :
                n_yaml(n_yaml) {};
#endif
};

ExpectedYaml LoadFromFile(string file_path);
ExpectedYaml Load(string yaml_str);
ExpectedYaml Load(istream &str);
ExpectedYaml Load(io::Reader &reader);

using ExpectedStringVector = expected::ExpectedStringVector;
using KeyValueMap = unordered_map<string, string>;
using ExpectedKeyValueMap = expected::expected<KeyValueMap, error::Error>;

ExpectedStringVector ToStringVector(const yaml::Yaml &j);
ExpectedKeyValueMap ToKeyValueMap(const yaml::Yaml &j);
ExpectedString ToString(const yaml::Yaml &j);
ExpectedInt64 ToInt64(const yaml::Yaml &j);
ExpectedBool ToBool(const yaml::Yaml &j);

template <typename T>
expected::expected<T, error::Error> To(const yaml::Yaml &j) {
        return j.Get<T>();
}

enum class MissingOk {
        No,
        Yes,
};

template <typename T>
expected::expected<T, error::Error> Get(
        const yaml::Yaml &yaml, const string &key, MissingOk missing_ok) {
        auto exp_value = yaml.Get(key);
        if (not exp_value) {
                if (missing_ok == MissingOk::Yes
                        and exp_value.error().code == yaml::MakeError(yaml::KeyError, "").code) {
                        return T();
                } else {
                        return expected::unexpected(
                                exp_value.error().WithContext(": Could not get `" + key + "` from the YAML data"));
                }
        }
        return exp_value.value().Get<T>();
}

} // namespace yaml
} // namespace common
} // namespace mender

#endif // MENDER_COMMON_YAML_HPP

1	// Copyright 2024 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	#ifndef MENDER_COMMON_YAML_HPP
16	#define MENDER_COMMON_YAML_HPP
17
18	#include <common/config.h>
19
20	#include <map>
21	#include <string>
22	#include <unordered_map>
23
24	#include <common/common.hpp>
25	#include <common/error.hpp>
26	#include <common/expected.hpp>
27	#include <common/io.hpp>
28
29	#ifdef MENDER_USE_YAML_CPP
30	#include <yaml-cpp/yaml.h>
31	#endif
32
33	namespace mender {
34	namespace common {
35	namespace yaml {
36
37	using namespace std;
38
39	namespace error = mender::common::error;
40	namespace io = mender::common::io;
41	namespace common = mender::common;
42
43	enum YamlErrorCode {
44	NoError = 0,
45	ParseError,
46	KeyError,
47	IndexError,
48	TypeError,
49	};
50
UNCOV 51	class YamlErrorCategoryClass : public error_category {	×
52	public:
53	const char *name() const noexcept override;
54	string message(int code) const override;
55	};
56	extern const YamlErrorCategoryClass YamlErrorCategory;
57
58	error::Error MakeError(YamlErrorCode code, const string &msg);
59
60	using ExpectedString = mender::common::expected::ExpectedString;
61	using ExpectedInt64 = mender::common::expected::ExpectedInt64;
62	using ExpectedDouble = mender::common::expected::ExpectedDouble;
63	using ExpectedBool = mender::common::expected::ExpectedBool;
64	using ExpectedSize = mender::common::expected::ExpectedSize;
65
66	class Yaml;
67	using ExpectedYaml = expected::expected<Yaml, error::Error>;
68	using ChildrenMap = map<string, Yaml>;
69	using ExpectedChildrenMap = expected::expected<ChildrenMap, error::Error>;
70
UNCOV 71	class Yaml {	×
72	public:
73	Yaml() = default;
74
75	Yaml(const Yaml &) = default;
76	Yaml &operator=(const Yaml &) = default;
77
78	Yaml(Yaml &&) = default;
79	Yaml &operator=(Yaml &&) = default;
80
81	string Dump(const int indent = 2) const;
82
83	ExpectedYaml Get(const char *child_key) const;
84	ExpectedYaml operator[](const char *child_key) const {
85	return this->Get(child_key);
86	}
87	ExpectedYaml Get(const string &child_key) const {
88	return this->Get(child_key.data());
89	}
90	ExpectedYaml operator[](const string &child_key) const {
91	return this->Get(child_key.data());
92	}
93	ExpectedYaml Get(const size_t idx) const;
94	ExpectedYaml operator[](const size_t idx) const {
95	return this->Get(idx);
96	}
97
98	ExpectedChildrenMap GetChildren() const;
99
100	bool IsObject() const;
101	bool IsArray() const;
102	bool IsString() const;
103	bool IsInt64() const;
104	bool IsNumber() const;
105	bool IsDouble() const;
106	bool IsBool() const;
107	bool IsNull() const;
108
109	// Defined in cpp file as specialized templates.
110	template <typename T>
111	typename enable_if<
112	not is_integral<T>::value or is_same<T, int64_t>::value or is_same<T, bool>::value,
113	expected::expected<T, error::Error>>::type
114	Get() const;
115
116	// Use this as a catch-all for all integral types besides int64_t and bool. It then
117	// automates the process of checking whether it fits in the requested data type.
118	template <typename T>
119	typename enable_if<
120	is_integral<T>::value and not is_same<T, int64_t>::value and not is_same<T, bool>::value,
121	expected::expected<T, error::Error>>::type
122	Get() const {
123	auto num = Get<int64_t>();
124	if (!num) {
125	return expected::unexpected(num.error());
126	}
127	bool fits = true;
128	if (is_signed<T>()) {
129	if (num.value() < numeric_limits<T>::lowest()
130	or num.value() > numeric_limits<T>::max()) {
131	fits = false;
132	}
133	} else {
134	if (static_cast<unsigned long long>(num.value()) > numeric_limits<T>::max()) {
135	fits = false;
136	}
137	}
138	if (not fits) {
139	return expected::unexpected(error::Error(
140	make_error_condition(errc::result_out_of_range),
141	"Json::Get(): Number " + to_string(num.value())
142	+ " does not fit in requested data type"));
143	}
144	return static_cast<T>(num.value());
145	}
146
147	ExpectedSize GetArraySize() const;
148
149	string GetType() const;
150	friend std::ostream &operator<<(std::ostream &os, const Yaml &y) {
151	#ifdef MENDER_USE_YAML_CPP
152	os << y.n_yaml;
153	#endif
154	return os;
155	}
156
157	friend ExpectedYaml LoadFromFile(string file_path);
158	friend ExpectedYaml Load(string yaml_str);
159	friend ExpectedYaml Load(istream &str);
160	friend ExpectedYaml Load(io::Reader &reader);
161
162	public:
163	#ifdef MENDER_USE_YAML_CPP
164	YAML::Node n_yaml;
165	Yaml(YAML::Node n_yaml) :
166	n_yaml(n_yaml) {};
167	#endif
168	};
169
170	ExpectedYaml LoadFromFile(string file_path);
171	ExpectedYaml Load(string yaml_str);
172	ExpectedYaml Load(istream &str);
173	ExpectedYaml Load(io::Reader &reader);
174
175	using ExpectedStringVector = expected::ExpectedStringVector;
176	using KeyValueMap = unordered_map<string, string>;
177	using ExpectedKeyValueMap = expected::expected<KeyValueMap, error::Error>;
178
179	ExpectedStringVector ToStringVector(const yaml::Yaml &j);
180	ExpectedKeyValueMap ToKeyValueMap(const yaml::Yaml &j);
181	ExpectedString ToString(const yaml::Yaml &j);
182	ExpectedInt64 ToInt64(const yaml::Yaml &j);
183	ExpectedBool ToBool(const yaml::Yaml &j);
184
185	template <typename T>
186	expected::expected<T, error::Error> To(const yaml::Yaml &j) {
187	return j.Get<T>();
188	}
189
190	enum class MissingOk {
191	No,
192	Yes,
193	};
194
195	template <typename T>
196	expected::expected<T, error::Error> Get(
197	const yaml::Yaml &yaml, const string &key, MissingOk missing_ok) {
198	auto exp_value = yaml.Get(key);
199	if (not exp_value) {
200	if (missing_ok == MissingOk::Yes
201	and exp_value.error().code == yaml::MakeError(yaml::KeyError, "").code) {
202	return T();
203	} else {
204	return expected::unexpected(
205	exp_value.error().WithContext(": Could not get `" + key + "` from the YAML data"));
206	}
207	}
208	return exp_value.value().Get<T>();
209	}
210
211	} // namespace yaml
212	} // namespace common
213	} // namespace mender
214
215	#endif // MENDER_COMMON_YAML_HPP

mendersoftware / mender / 1583599051

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