2098753807

Committed 14 Oct 2025 01:25PM UTC coverage: 75.947% (-0.01%) from 75.957%

Build # 2098753807

Build Type

Pull #1838

gitlab-ci

Committed by

mender-test-bot

Commit Message

test: Add longer timeouts for HTTP tests reaching external services

The test `CorrectDefaultCertificateStoreVerification` occasionally fails
in CI with a timeout.

The rest of the tests communicate with localhost, which we should assume
its reachable within the 5 seconds deafault timeout. But for the ones
connecting externally give some extra time for more stability in CI.

Ticket: QA-1223

Signed-off-by: Lluis Campos <lluis.campos@northern.tech>
(cherry picked from commit 69b5b337b)

Pull Request Pull Request #1838: [Cherry 5.0.x]: QA-1223: Add longer timeouts for HTTP tests reaching external services

Run Details

7398 of 9741 relevant lines covered (75.95%)

13921.55 hits per line

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

83.77

/src/mender-update/update_module/v3/update_module_download.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/update_module/v3/update_module.hpp>

#include <mender-update/progress_reader/progress_reader.hpp>

#include <common/events.hpp>
#include <common/events_io.hpp>
#include <common/log.hpp>
#include <common/path.hpp>
#include <common/processes.hpp>

namespace mender {
namespace update {
namespace update_module {
namespace v3 {

namespace log = mender::common::log;
namespace path = mender::common::path;
namespace processes = mender::common::processes;
namespace progress = mender::update::progress;


void UpdateModule::StartDownloadProcess() {
        string download_command = "Download";
        if (download_->downloading_with_sizes_) {
                download_command = "DownloadWithFileSizes";
        }
        log::Debug(
                "Calling Update Module with command `" + update_module_path_ + " " + download_command + " "
                + update_module_workdir_ + "`.");
        download_->proc_ = make_shared<procs::Process>(
                vector<string> {update_module_path_, download_command, update_module_workdir_});

        download_->proc_->SetWorkDir(update_module_workdir_);

        auto err = PrepareStreamNextPipe();
        if (err != error::NoError) {
                DownloadErrorHandler(err);
                return;
        }

        processes::OutputHandler stdout_handler {"Update Module output (stdout): "};
        processes::OutputHandler stderr_handler {"Update Module output (stderr): "};

        err = download_->proc_->Start(stdout_handler, stderr_handler);
        if (err != error::NoError) {
                DownloadErrorHandler(GetProcessError(err));
                return;
        }

        err = download_->proc_->AsyncWait(
                download_->event_loop_,
                [this](error::Error err) {
                        if (err.code == make_error_condition(errc::timed_out)) {
                                DownloadTimeoutHandler();
                        } else {
                                ProcessEndedHandler(err);
                        }
                },
                chrono::seconds(ctx_.GetConfig().module_timeout_seconds));
        if (err != error::NoError) {
                DownloadErrorHandler(err);
                return;
        }

        DownloadErrorHandler(OpenStreamNextPipe(
                [this](io::ExpectedAsyncWriterPtr writer) { StreamNextOpenHandler(writer); }));
}

void UpdateModule::StreamNextOpenHandler(io::ExpectedAsyncWriterPtr writer) {
        if (!writer) {
                DownloadErrorHandler(writer.error());
                return;
        }
        download_->stream_next_writer_ = writer.value();

        download_->module_has_started_download_ = true;

        auto reader = download_->payload_.Next();
        if (!reader) {
                if (reader.error().code
                        == artifact::parser_error::MakeError(
                                   artifact::parser_error::NoMorePayloadFilesError, "")
                                   .code) {
                        download_->module_has_finished_download_ = true;
                        log::Debug("Update Module finished all downloads");
                        EndStreamNext();
                } else {
                        DownloadErrorHandler(reader.error());
                }
                return;
        }
        auto payload_reader = make_shared<artifact::Reader>(std::move(reader.value()));

        auto progress_reader = make_shared<progress::Reader>(payload_reader, payload_reader->Size());

        download_->current_payload_reader_ =
                make_shared<events::io::AsyncReaderFromReader>(download_->event_loop_, progress_reader);
        download_->current_payload_name_ = payload_reader->Name();
        download_->current_payload_size_ = payload_reader->Size();

        auto stream_path =
                path::Join(update_module_workdir_, string("streams"), download_->current_payload_name_);
        auto err = PrepareAndOpenStreamPipe(
                stream_path, [this](io::ExpectedAsyncWriterPtr writer) { StreamOpenHandler(writer); });
        if (err != error::NoError) {
                DownloadErrorHandler(err);
                return;
        }

        string stream_next_string;
        if (download_->downloading_with_sizes_) {
                stream_next_string = path::Join("streams", download_->current_payload_name_) + " "
                                                         + to_string(download_->current_payload_size_);
        } else {
                stream_next_string = path::Join("streams", download_->current_payload_name_);
        }
        size_t entry_size = stream_next_string.size() + 1;
        if (entry_size > download_->buffer_.size()) {
                DownloadErrorHandler(error::Error(
                        make_error_condition(errc::no_buffer_space), "Payload name is too large for buffer"));
                return;
        }
        copy(stream_next_string.begin(), stream_next_string.end(), download_->buffer_.begin());
        download_->buffer_[entry_size - 1] = '\n';
        DownloadErrorHandler(download_->stream_next_writer_->AsyncWrite(
                download_->buffer_.begin(),
                download_->buffer_.begin() + entry_size,
                [this, entry_size](io::ExpectedSize result) {
                        StreamNextWriteHandler(entry_size, result);
                }));
}

void UpdateModule::StreamOpenHandler(io::ExpectedAsyncWriterPtr writer) {
        if (!writer) {
                DownloadErrorHandler(writer.error());
                return;
        }
        download_->current_stream_writer_ = writer.value();

        DownloadErrorHandler(download_->current_payload_reader_->AsyncRead(
                download_->buffer_.begin(), download_->buffer_.end(), [this](io::ExpectedSize result) {
                        PayloadReadHandler(result);
                }));
}

void UpdateModule::StreamNextWriteHandler(size_t expected_n, io::ExpectedSize result) {
        // Close stream-next writer.
        download_->stream_next_writer_.reset();
        if (!result) {
                DownloadErrorHandler(result.error());
        } else if (expected_n != result.value()) {
                DownloadErrorHandler(error::Error(
                        make_error_condition(errc::io_error),
                        "Unexpected number of written bytes to stream-next"));
        }
}

void UpdateModule::PayloadReadHandler(io::ExpectedSize result) {
        if (!result) {
                // Close streams.
                download_->current_stream_writer_.reset();
                download_->current_payload_reader_.reset();
                DownloadErrorHandler(result.error());
        } else if (result.value() > 0) {
                DownloadErrorHandler(download_->current_stream_writer_->AsyncWrite(
                        download_->buffer_.begin(),
                        download_->buffer_.begin() + result.value(),
                        [this, result](io::ExpectedSize write_result) {
                                StreamWriteHandler(0, result.value(), write_result);
                        }));
        } else {
                // Close streams.
                download_->current_stream_writer_.reset();
                download_->current_payload_reader_.reset();

                if (download_->downloading_to_files_) {
                        StartDownloadToFile();
                } else {
                        DownloadErrorHandler(OpenStreamNextPipe(
                                [this](io::ExpectedAsyncWriterPtr writer) { StreamNextOpenHandler(writer); }));
                }
        }
}

void UpdateModule::StreamWriteHandler(size_t offset, size_t expected_n, io::ExpectedSize result) {
        if (!result) {
                DownloadErrorHandler(result.error());
        } else if (result.value() == 0 || result.value() > expected_n) {
                DownloadErrorHandler(error::Error(
                        make_error_condition(errc::io_error),
                        "Unexpected number of written bytes to download stream"));
        } else if (result.value() < expected_n) {
                auto new_offset = offset + result.value();
                auto new_expected = expected_n - result.value();
                DownloadErrorHandler(download_->current_stream_writer_->AsyncWrite(
                        download_->buffer_.begin() + new_offset,
                        download_->buffer_.begin() + new_offset + new_expected,
                        [this, new_offset, new_expected](io::ExpectedSize write_result) {
                                StreamWriteHandler(new_offset, new_expected, write_result);
                        }));
        } else {
                download_->written_ += result.value();
                log::Trace("Wrote " + to_string(download_->written_) + " bytes to Update Module");
                DownloadErrorHandler(download_->current_payload_reader_->AsyncRead(
                        download_->buffer_.begin(), download_->buffer_.end(), [this](io::ExpectedSize result) {
                                PayloadReadHandler(result);
                        }));
        }
}

void UpdateModule::EndStreamNext() {
        // Empty write.
        DownloadErrorHandler(download_->stream_next_writer_->AsyncWrite(
                download_->buffer_.begin(), download_->buffer_.begin(), [this](io::ExpectedSize result) {
                        if (!result) {
                                DownloadErrorHandler(result.error());
                        } else {
                                DownloadErrorHandler(error::NoError);
                        }
                        // Close writer.
                        download_->stream_next_writer_.reset();
                        // No further action necessary. Now we just need to wait for the process to finish.
                }));
}

void UpdateModule::DownloadErrorHandler(const error::Error &err) {
        if (err != error::NoError) {
                EndDownloadLoop(err);
        }
}

void UpdateModule::EndDownloadLoop(const error::Error &err) {
        download_->download_finished_handler_(err);
}

void UpdateModule::DownloadTimeoutHandler() {
        download_->proc_->EnsureTerminated();
        EndDownloadLoop(error::Error(
                make_error_condition(errc::timed_out), "Update Module Download process timed out"));
}

void UpdateModule::ProcessEndedHandler(error::Error err) {
        if (err != error::NoError) {
                err = GetProcessError(err);
                DownloadErrorHandler(error::Error(
                        err.code, "Download: Update Module returned non-zero status: " + err.message));
        } else if (download_->module_has_finished_download_) {
                EndDownloadLoop(error::NoError);
        } else if (download_->module_has_started_download_) {
                DownloadErrorHandler(error::Error(
                        make_error_condition(errc::broken_pipe),
                        "Update Module started downloading, but did not finish"));
        } else {
                download_->downloading_to_files_ = true;
                download_->stream_next_opener_.reset();
                download_->current_stream_opener_.reset();
                err = DeleteStreamsFiles();
                if (err != error::NoError) {
                        DownloadErrorHandler(err);
                } else {
                        StartDownloadToFile();
                }
        }
}

void UpdateModule::StartDownloadToFile() {
        auto reader = download_->payload_.Next();
        if (!reader) {
                if (reader.error().code
                        == artifact::parser_error::MakeError(
                                   artifact::parser_error::NoMorePayloadFilesError, "")
                                   .code) {
                        log::Debug("Downloaded all files to `files` directory.");
                        EndDownloadLoop(error::NoError);
                } else {
                        DownloadErrorHandler(reader.error());
                }
                return;
        }
        auto payload_reader = make_shared<artifact::Reader>(std::move(reader.value()));
        download_->current_payload_reader_ =
                make_shared<events::io::AsyncReaderFromReader>(download_->event_loop_, payload_reader);
        download_->current_payload_name_ = payload_reader->Name();

        auto stream_path = path::Join(update_module_workdir_, string("files"));
        auto err = PrepareDownloadDirectory(stream_path);
        if (err != error::NoError) {
                DownloadErrorHandler(err);
                return;
        }

        stream_path = path::Join(stream_path, download_->current_payload_name_);

        auto current_stream_writer =
                make_shared<events::io::AsyncFileDescriptorWriter>(download_->event_loop_);
        err = current_stream_writer->Open(stream_path);
        if (err != error::NoError) {
                DownloadErrorHandler(err);
                return;
        }
        download_->current_stream_writer_ = current_stream_writer;

        DownloadErrorHandler(download_->current_payload_reader_->AsyncRead(
                download_->buffer_.begin(), download_->buffer_.end(), [this](io::ExpectedSize result) {
                        PayloadReadHandler(result);
                }));
}

} // namespace v3
} // namespace update_module
} // 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/update_module/v3/update_module.hpp>
16
17	#include <mender-update/progress_reader/progress_reader.hpp>
18
19	#include <common/events.hpp>
20	#include <common/events_io.hpp>
21	#include <common/log.hpp>
22	#include <common/path.hpp>
23	#include <common/processes.hpp>
24
25	namespace mender {
26	namespace update {
27	namespace update_module {
28	namespace v3 {
29
30	namespace log = mender::common::log;
31	namespace path = mender::common::path;
32	namespace processes = mender::common::processes;
33	namespace progress = mender::update::progress;
34
35
36	void UpdateModule::StartDownloadProcess() {	117✔
37	string download_command = "Download";	117✔
38	if (download_->downloading_with_sizes_) {	117✔
39	download_command = "DownloadWithFileSizes";	3✔
40	}
41	log::Debug(	117✔
42	"Calling Update Module with command `" + update_module_path_ + " " + download_command + " "	234✔
43	+ update_module_workdir_ + "`.");	351✔
44	download_->proc_ = make_shared<procs::Process>(	117✔
45	vector<string> {update_module_path_, download_command, update_module_workdir_});	585✔
46
47	download_->proc_->SetWorkDir(update_module_workdir_);
48
49	auto err = PrepareStreamNextPipe();	117✔
50	if (err != error::NoError) {	117✔
51	DownloadErrorHandler(err);	×
52	return;
53	}
54
55	processes::OutputHandler stdout_handler {"Update Module output (stdout): "};	117✔
56	processes::OutputHandler stderr_handler {"Update Module output (stderr): "};	117✔
57
58	err = download_->proc_->Start(stdout_handler, stderr_handler);	351✔
59	if (err != error::NoError) {	117✔
60	DownloadErrorHandler(GetProcessError(err));	×
61	return;	×
62	}
63
64	err = download_->proc_->AsyncWait(	117✔
65	download_->event_loop_,
66	[this](error::Error err) {	232✔
67	if (err.code == make_error_condition(errc::timed_out)) {	116✔
68	DownloadTimeoutHandler();	2✔
69	} else {
70	ProcessEndedHandler(err);	228✔
71	}
72	},	116✔
73	chrono::seconds(ctx_.GetConfig().module_timeout_seconds));	117✔
74	if (err != error::NoError) {	117✔
75	DownloadErrorHandler(err);	×
76	return;
77	}
78
79	DownloadErrorHandler(OpenStreamNextPipe(	234✔
80	[this](io::ExpectedAsyncWriterPtr writer) { StreamNextOpenHandler(writer); }));	252✔
81	}
82
83	void UpdateModule::StreamNextOpenHandler(io::ExpectedAsyncWriterPtr writer) {	13✔
84	if (!writer) {	13✔
85	DownloadErrorHandler(writer.error());	×
86	return;	3✔
87	}
88	download_->stream_next_writer_ = writer.value();	13✔
89
90	download_->module_has_started_download_ = true;	13✔
91
92	auto reader = download_->payload_.Next();	13✔
93	if (!reader) {	13✔
94	if (reader.error().code	3✔
95	== artifact::parser_error::MakeError(	3✔
96	artifact::parser_error::NoMorePayloadFilesError, "")	6✔
97	.code) {
98	download_->module_has_finished_download_ = true;	3✔
99	log::Debug("Update Module finished all downloads");	6✔
100	EndStreamNext();	3✔
101	} else {
102	DownloadErrorHandler(reader.error());	×
103	}
104	return;	3✔
105	}
106	auto payload_reader = make_shared<artifact::Reader>(std::move(reader.value()));	10✔
107
108	auto progress_reader = make_shared<progress::Reader>(payload_reader, payload_reader->Size());	10✔
109
110	download_->current_payload_reader_ =
111	make_shared<events::io::AsyncReaderFromReader>(download_->event_loop_, progress_reader);	20✔
112	download_->current_payload_name_ = payload_reader->Name();	20✔
113	download_->current_payload_size_ = payload_reader->Size();	10✔
114
115	auto stream_path =
116	path::Join(update_module_workdir_, string("streams"), download_->current_payload_name_);	20✔
117	auto err = PrepareAndOpenStreamPipe(
118	stream_path, [this](io::ExpectedAsyncWriterPtr writer) { StreamOpenHandler(writer); });	22✔
119	if (err != error::NoError) {	10✔
120	DownloadErrorHandler(err);	×
121	return;
122	}
123
124	string stream_next_string;
125	if (download_->downloading_with_sizes_) {	10✔
126	stream_next_string = path::Join("streams", download_->current_payload_name_) + " "	2✔
127	+ to_string(download_->current_payload_size_);	4✔
128	} else {
129	stream_next_string = path::Join("streams", download_->current_payload_name_);	18✔
130	}
131	size_t entry_size = stream_next_string.size() + 1;	10✔
132	if (entry_size > download_->buffer_.size()) {	10✔
133	DownloadErrorHandler(error::Error(	×
134	make_error_condition(errc::no_buffer_space), "Payload name is too large for buffer"));	×
135	return;
136	}
137	copy(stream_next_string.begin(), stream_next_string.end(), download_->buffer_.begin());	10✔
138	download_->buffer_[entry_size - 1] = '\n';	10✔
139	DownloadErrorHandler(download_->stream_next_writer_->AsyncWrite(	10✔
140	download_->buffer_.begin(),
141	download_->buffer_.begin() + entry_size,
142	[this, entry_size](io::ExpectedSize result) {	9✔
143	StreamNextWriteHandler(entry_size, result);	9✔
144	}));	29✔
145	}
146
147	void UpdateModule::StreamOpenHandler(io::ExpectedAsyncWriterPtr writer) {	6✔
148	if (!writer) {	6✔
149	DownloadErrorHandler(writer.error());	×
150	return;	×
151	}
152	download_->current_stream_writer_ = writer.value();	6✔
153
154	DownloadErrorHandler(download_->current_payload_reader_->AsyncRead(	12✔
155	download_->buffer_.begin(), download_->buffer_.end(), [this](io::ExpectedSize result) {	6✔
156	PayloadReadHandler(result);	6✔
157	}));	18✔
158	}
159
160	void UpdateModule::StreamNextWriteHandler(size_t expected_n, io::ExpectedSize result) {	9✔
161	// Close stream-next writer.
162	download_->stream_next_writer_.reset();	9✔
163	if (!result) {	9✔
164	DownloadErrorHandler(result.error());	×
165	} else if (expected_n != result.value()) {	9✔
166	DownloadErrorHandler(error::Error(	×
167	make_error_condition(errc::io_error),	×
168	"Unexpected number of written bytes to stream-next"));	×
169	}
170	}	9✔
171
172	void UpdateModule::PayloadReadHandler(io::ExpectedSize result) {	628✔
173	if (!result) {	628✔
174	// Close streams.
175	download_->current_stream_writer_.reset();	×
176	download_->current_payload_reader_.reset();	×
177	DownloadErrorHandler(result.error());	×
178	} else if (result.value() > 0) {	628✔
179	DownloadErrorHandler(download_->current_stream_writer_->AsyncWrite(	567✔
180	download_->buffer_.begin(),
181	download_->buffer_.begin() + result.value(),	567✔
182	[this, result](io::ExpectedSize write_result) {	1,701✔
183	StreamWriteHandler(0, result.value(), write_result);	567✔
184	}));	2,268✔
185	} else {
186	// Close streams.
187	download_->current_stream_writer_.reset();	61✔
188	download_->current_payload_reader_.reset();	61✔
189
190	if (download_->downloading_to_files_) {	61✔
191	StartDownloadToFile();	56✔
192	} else {
193	DownloadErrorHandler(OpenStreamNextPipe(	10✔
194	[this](io::ExpectedAsyncWriterPtr writer) { StreamNextOpenHandler(writer); }));	18✔
195	}
196	}
197	}	628✔
198
199	void UpdateModule::StreamWriteHandler(size_t offset, size_t expected_n, io::ExpectedSize result) {	567✔
200	if (!result) {	567✔
201	DownloadErrorHandler(result.error());	1✔
202	} else if (result.value() == 0 \|\| result.value() > expected_n) {	566✔
203	DownloadErrorHandler(error::Error(	×
204	make_error_condition(errc::io_error),	×
205	"Unexpected number of written bytes to download stream"));	×
206	} else if (result.value() < expected_n) {	566✔
207	auto new_offset = offset + result.value();	×
208	auto new_expected = expected_n - result.value();	×
209	DownloadErrorHandler(download_->current_stream_writer_->AsyncWrite(	×
210	download_->buffer_.begin() + new_offset,
211	download_->buffer_.begin() + new_offset + new_expected,
212	[this, new_offset, new_expected](io::ExpectedSize write_result) {	×
213	StreamWriteHandler(new_offset, new_expected, write_result);	×
214	}));	×
215	} else {
216	download_->written_ += result.value();	566✔
217	log::Trace("Wrote " + to_string(download_->written_) + " bytes to Update Module");	1,132✔
218	DownloadErrorHandler(download_->current_payload_reader_->AsyncRead(	1,132✔
219	download_->buffer_.begin(), download_->buffer_.end(), [this](io::ExpectedSize result) {	566✔
220	PayloadReadHandler(result);	566✔
221	}));	1,698✔
222	}
223	}	567✔
224
225	void UpdateModule::EndStreamNext() {	3✔
226	// Empty write.
227	DownloadErrorHandler(download_->stream_next_writer_->AsyncWrite(	3✔
228	download_->buffer_.begin(), download_->buffer_.begin(), [this](io::ExpectedSize result) {	6✔
229	if (!result) {	3✔
230	DownloadErrorHandler(result.error());	×
231	} else {
232	DownloadErrorHandler(error::NoError);	3✔
233	}
234	// Close writer.
235	download_->stream_next_writer_.reset();	3✔
236	// No further action necessary. Now we just need to wait for the process to finish.
237	}));	6✔
238	}	3✔
239
240	void UpdateModule::DownloadErrorHandler(const error::Error &err) {	1,343✔
241	if (err != error::NoError) {	1,343✔
242	EndDownloadLoop(err);	10✔
243	}
244	}	1,343✔
245
246	void UpdateModule::EndDownloadLoop(const error::Error &err) {	117✔
247	download_->download_finished_handler_(err);	117✔
248	}	117✔
249
250	void UpdateModule::DownloadTimeoutHandler() {	2✔
251	download_->proc_->EnsureTerminated();	2✔
252	EndDownloadLoop(error::Error(	2✔
253	make_error_condition(errc::timed_out), "Update Module Download process timed out"));	4✔
254	}	2✔
255
256	void UpdateModule::ProcessEndedHandler(error::Error err) {	114✔
257	if (err != error::NoError) {	114✔
258	err = GetProcessError(err);	5✔
259	DownloadErrorHandler(error::Error(	10✔
260	err.code, "Download: Update Module returned non-zero status: " + err.message));	10✔
261	} else if (download_->module_has_finished_download_) {	109✔
262	EndDownloadLoop(error::NoError);	3✔
263	} else if (download_->module_has_started_download_) {	106✔
264	DownloadErrorHandler(error::Error(	3✔
265	make_error_condition(errc::broken_pipe),	6✔
266	"Update Module started downloading, but did not finish"));	6✔
267	} else {
268	download_->downloading_to_files_ = true;	103✔
269	download_->stream_next_opener_.reset();	103✔
270	download_->current_stream_opener_.reset();	103✔
271	err = DeleteStreamsFiles();	103✔
272	if (err != error::NoError) {	103✔
273	DownloadErrorHandler(err);	×
274	} else {
275	StartDownloadToFile();	103✔
276	}
277	}
278	}	114✔
279
280	void UpdateModule::StartDownloadToFile() {	159✔
281	auto reader = download_->payload_.Next();	159✔
282	if (!reader) {	159✔
283	if (reader.error().code	102✔
284	== artifact::parser_error::MakeError(	102✔
285	artifact::parser_error::NoMorePayloadFilesError, "")	204✔
286	.code) {
287	log::Debug("Downloaded all files to `files` directory.");	204✔
288	EndDownloadLoop(error::NoError);	102✔
289	} else {
290	DownloadErrorHandler(reader.error());	×
291	}
292	return;	102✔
293	}
294	auto payload_reader = make_shared<artifact::Reader>(std::move(reader.value()));	57✔
295	download_->current_payload_reader_ =
296	make_shared<events::io::AsyncReaderFromReader>(download_->event_loop_, payload_reader);	114✔
297	download_->current_payload_name_ = payload_reader->Name();	57✔
298
299	auto stream_path = path::Join(update_module_workdir_, string("files"));	114✔
300	auto err = PrepareDownloadDirectory(stream_path);	57✔
301	if (err != error::NoError) {	57✔
302	DownloadErrorHandler(err);	×
303	return;
304	}
305
306	stream_path = path::Join(stream_path, download_->current_payload_name_);	114✔
307
308	auto current_stream_writer =
309	make_shared<events::io::AsyncFileDescriptorWriter>(download_->event_loop_);	57✔
310	err = current_stream_writer->Open(stream_path);	57✔
311	if (err != error::NoError) {	57✔
312	DownloadErrorHandler(err);	1✔
313	return;
314	}
315	download_->current_stream_writer_ = current_stream_writer;
316
317	DownloadErrorHandler(download_->current_payload_reader_->AsyncRead(	112✔
318	download_->buffer_.begin(), download_->buffer_.end(), [this](io::ExpectedSize result) {	56✔
319	PayloadReadHandler(result);	56✔
320	}));	168✔
321	}
322
323	} // namespace v3
324	} // namespace update_module
325	} // namespace update
326	} // namespace mender

mendersoftware / mender / 2098753807

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