2378429566

Committed 11 Mar 2026 01:27PM UTC coverage: 81.7% (+0.02%) from 81.684%

Build # 2378429566

Build Type

Pull #1913

gitlab-ci

Committed by

mender-test-bot

Commit Message

fix: Don't retry status update on 413

Changelog: Added an explicit check for 413 Request Body Too Large errors
when sending deployment logs in order to not go into an unnecessary retry
loop when the deployment logs are too big.

Ticket: ME-616

Signed-off-by: Daniel Skinstad Drabitzius <daniel.drabitzius@northern.tech>
(cherry picked from commit 682e48073)

Pull Request Pull Request #1913: [Cherry 5.1.x]: fix: Don't retry status update on 413

Coverage Stats

6 of 9 new or added lines in 3 files covered. (66.67%)

9005 of 11022 relevant lines covered (81.7%)

19911.0 hits per line

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

81.65

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

#include <algorithm>
#include <sstream>
#include <string>

#include <api/api.hpp>
#include <api/client.hpp>
#include <common/common.hpp>
#include <common/error.hpp>
#include <common/events.hpp>
#include <common/expected.hpp>
#include <common/http.hpp>
#include <common/io.hpp>
#include <common/json.hpp>
#include <common/log.hpp>
#include <common/optional.hpp>
#include <common/path.hpp>
#include <mender-update/context.hpp>

namespace mender {
namespace update {
namespace deployments {

using namespace std;

namespace api = mender::api;
namespace common = mender::common;
namespace context = mender::update::context;
namespace error = mender::common::error;
namespace events = mender::common::events;
namespace expected = mender::common::expected;
namespace http = mender::common::http;
namespace io = mender::common::io;
namespace json = mender::common::json;
namespace log = mender::common::log;
namespace path = mender::common::path;

const DeploymentsErrorCategoryClass DeploymentsErrorCategory;

const char *DeploymentsErrorCategoryClass::name() const noexcept {
        return "DeploymentsErrorCategory";
}

string DeploymentsErrorCategoryClass::message(int code) const {
        switch (code) {
        case NoError:
                return "Success";
        case InvalidDataError:
                return "Invalid data error";
        case BadResponseError:
                return "Bad response error";
        case DeploymentAbortedError:
                return "Deployment was aborted on the server";
        case TooManyRequestsError:
                return "Too many requests";
        case RequestBodyTooLargeError:
                return "Request body too large";
        }
        assert(false);
        return "Unknown";
}

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

static const string check_updates_v1_uri = "/api/devices/v1/deployments/device/deployments/next";
static const string check_updates_v2_uri = "/api/devices/v2/deployments/device/deployments/next";

error::Error DeploymentClient::CheckNewDeployments(
        context::MenderContext &ctx, api::Client &client, CheckUpdatesAPIResponseHandler api_handler) {
        auto ex_compatible_type = ctx.GetCompatibleType();
        if (!ex_compatible_type) {
                return ex_compatible_type.error();
        }
        string compatible_type = ex_compatible_type.value();

        auto ex_provides = ctx.LoadProvides();
        if (!ex_provides) {
                return ex_provides.error();
        }
        auto provides = ex_provides.value();
        if (provides.find("artifact_name") == provides.end()) {
                return MakeError(InvalidDataError, "Missing artifact name data");
        }

        stringstream ss;
        ss << R"({"device_provides":{)";
        ss << R"("device_type":")";
        ss << json::EscapeString(compatible_type);

        for (const auto &kv : provides) {
                ss << "\",\"" + json::EscapeString(kv.first) + "\":\"";
                ss << json::EscapeString(kv.second);
        }

        ss << R"("}})";

        string v2_payload = ss.str();
        log::Debug("deployments/next v2 payload " + v2_payload);
        http::BodyGenerator payload_gen = [v2_payload]() {
                return make_shared<io::StringReader>(v2_payload);
        };

        auto v2_req = make_shared<api::APIRequest>();
        v2_req->SetPath(check_updates_v2_uri);
        v2_req->SetMethod(http::Method::POST);
        v2_req->SetHeader("Content-Type", "application/json");
        v2_req->SetHeader("Content-Length", to_string(v2_payload.size()));
        v2_req->SetHeader("Accept", "application/json");
        v2_req->SetBodyGenerator(payload_gen);

        string v1_args = "artifact_name=" + http::URLEncode(provides["artifact_name"])
                                         + "&device_type=" + http::URLEncode(compatible_type);
        auto v1_req = make_shared<api::APIRequest>();
        v1_req->SetPath(check_updates_v1_uri + "?" + v1_args);
        v1_req->SetMethod(http::Method::GET);
        v1_req->SetHeader("Accept", "application/json");

        auto received_body = make_shared<vector<uint8_t>>();
        auto handle_data = [received_body, api_handler](unsigned status) {
                if (status == http::StatusOK) {
                        auto ex_j = json::Load(common::StringFromByteVector(*received_body));
                        if (ex_j) {
                                CheckUpdatesAPIResponse response {optional<json::Json> {ex_j.value()}};
                                api_handler(response);
                        } else {
                                api_handler(expected::unexpected(
                                        CheckUpdatesAPIResponseError {status, nullopt, ex_j.error()}));
                        }
                } else if (status == http::StatusNoContent) {
                        api_handler(CheckUpdatesAPIResponse {nullopt});
                } else {
                        log::Warning(
                                "DeploymentClient::CheckNewDeployments - received unhandled http response: "
                                + to_string(status));
                        api_handler(expected::unexpected(CheckUpdatesAPIResponseError {
                                status,
                                nullopt,
                                MakeError(
                                        DeploymentAbortedError,
                                        "received unhandled HTTP response: " + to_string(status))}));
                }
        };

        http::ResponseHandler header_handler =
                [this, received_body, api_handler](http::ExpectedIncomingResponsePtr exp_resp) {
                        this->HeaderHandler(received_body, api_handler, exp_resp);
                };

        http::ResponseHandler v1_body_handler =
                [received_body, api_handler, handle_data](http::ExpectedIncomingResponsePtr exp_resp) {
                        if (!exp_resp) {
                                log::Error("Request to check new deployments failed: " + exp_resp.error().message);
                                CheckUpdatesAPIResponse response = expected::unexpected(
                                        CheckUpdatesAPIResponseError {nullopt, nullopt, exp_resp.error()});
                                api_handler(response);
                                return;
                        }
                        auto resp = exp_resp.value();
                        auto status = resp->GetStatusCode();

                        // StatusTooManyRequests must have been handled in HeaderHandler already
                        assert(status != http::StatusTooManyRequests);

                        if ((status == http::StatusOK) || (status == http::StatusNoContent)) {
                                handle_data(status);
                        } else {
                                auto ex_err_msg = api::ErrorMsgFromErrorResponse(*received_body);
                                string err_str;
                                if (ex_err_msg) {
                                        err_str = ex_err_msg.value();
                                } else {
                                        err_str = resp->GetStatusMessage();
                                }
                                api_handler(expected::unexpected(CheckUpdatesAPIResponseError {
                                        status,
                                        nullopt,
                                        MakeError(
                                                BadResponseError,
                                                "Got unexpected response " + to_string(status) + ": " + err_str)}));
                        }
                };

        http::ResponseHandler v2_body_handler = [received_body,
                                                                                         v1_req,
                                                                                         header_handler,
                                                                                         v1_body_handler,
                                                                                         api_handler,
                                                                                         handle_data,
                                                                                         &client](http::ExpectedIncomingResponsePtr exp_resp) {
                if (!exp_resp) {
                        log::Error("Request to check new deployments failed: " + exp_resp.error().message);
                        CheckUpdatesAPIResponse response = expected::unexpected(
                                CheckUpdatesAPIResponseError {nullopt, nullopt, exp_resp.error()});
                        api_handler(response);
                        return;
                }
                auto resp = exp_resp.value();
                auto status = resp->GetStatusCode();

                // StatusTooManyRequests must have been handled in HeaderHandler already
                assert(status != http::StatusTooManyRequests);

                if ((status == http::StatusOK) || (status == http::StatusNoContent)) {
                        handle_data(status);
                } else if (status == http::StatusNotFound) {
                        log::Debug(
                                "POST request to v2 version of the deployments API failed, falling back to v1 version and GET");
                        auto err = client.AsyncCall(v1_req, header_handler, v1_body_handler);
                        if (err != error::NoError) {
                                api_handler(expected::unexpected(CheckUpdatesAPIResponseError {
                                        status, nullopt, err.WithContext("While calling v1 endpoint")}));
                        }
                } else {
                        auto ex_err_msg = api::ErrorMsgFromErrorResponse(*received_body);
                        string err_str;
                        if (ex_err_msg) {
                                err_str = ex_err_msg.value();
                        } else {
                                err_str = resp->GetStatusMessage();
                        }
                        api_handler(expected::unexpected(CheckUpdatesAPIResponseError {
                                status,
                                nullopt,
                                MakeError(
                                        BadResponseError,
                                        "Got unexpected response " + to_string(status) + ": " + err_str)}));
                }
        };

        return client.AsyncCall(v2_req, header_handler, v2_body_handler);
}

void DeploymentClient::HeaderHandler(
        shared_ptr<vector<uint8_t>> received_body,
        CheckUpdatesAPIResponseHandler api_handler,
        http::ExpectedIncomingResponsePtr exp_resp) {
        if (!exp_resp) {
                log::Error("Request to check new deployments failed: " + exp_resp.error().message);
                CheckUpdatesAPIResponse response =
                        expected::unexpected(CheckUpdatesAPIResponseError {nullopt, nullopt, exp_resp.error()});
                api_handler(response);
                return;
        }

        auto resp = exp_resp.value();
        auto status = resp->GetStatusCode();
        if (status == http::StatusTooManyRequests) {
                CheckUpdatesAPIResponse response = expected::unexpected(CheckUpdatesAPIResponseError {
                        status, resp->GetHeaders(), MakeError(TooManyRequestsError, "Too many requests")});
                api_handler(response);
        }
        received_body->clear();
        auto body_writer = make_shared<io::ByteWriter>(received_body);
        body_writer->SetUnlimited(true);
        resp->SetBodyWriter(body_writer);
}

static const string deployment_status_strings[static_cast<int>(DeploymentStatus::End_) + 1] = {
        "installing",
        "pause_before_installing",
        "downloading",
        "pause_before_rebooting",
        "rebooting",
        "pause_before_committing",
        "success",
        "failure",
        "already-installed"};

static const string deployments_uri_prefix = "/api/devices/v1/deployments/device/deployments";
static const string status_uri_suffix = "/status";

string DeploymentStatusString(DeploymentStatus status) {
        return deployment_status_strings[static_cast<int>(status)];
}

error::Error DeploymentClient::PushStatus(
        const string &deployment_id,
        DeploymentStatus status,
        const string &substate,
        api::Client &client,
        StatusAPIResponseHandler api_handler) {
        // Cannot push a status update without a deployment ID
        AssertOrReturnError(deployment_id != "");
        string payload = R"({"status":")" + DeploymentStatusString(status) + "\"";
        if (substate != "") {
                payload += R"(,"substate":")" + json::EscapeString(substate) + "\"}";
        } else {
                payload += "}";
        }
        http::BodyGenerator payload_gen = [payload]() {
                return make_shared<io::StringReader>(payload);
        };

        auto req = make_shared<api::APIRequest>();
        req->SetPath(http::JoinUrl(deployments_uri_prefix, deployment_id, status_uri_suffix));
        req->SetMethod(http::Method::PUT);
        req->SetHeader("Content-Type", "application/json");
        req->SetHeader("Content-Length", to_string(payload.size()));
        req->SetHeader("Accept", "application/json");
        req->SetBodyGenerator(payload_gen);

        auto received_body = make_shared<vector<uint8_t>>();
        return client.AsyncCall(
                req,
                [this, received_body, api_handler](http::ExpectedIncomingResponsePtr exp_resp) {
                        this->PushStatusHeaderHandler(received_body, api_handler, exp_resp);
                },
                [received_body, api_handler](http::ExpectedIncomingResponsePtr exp_resp) {
                        if (!exp_resp) {
                                log::Error("Request to push status data failed: " + exp_resp.error().message);
                                api_handler(StatusAPIResponse {nullopt, nullopt, exp_resp.error()});
                                return;
                        }

                        auto resp = exp_resp.value();
                        auto status = resp->GetStatusCode();

                        // StatusTooManyRequests must have been handled in PushStatusHeaderHandler already
                        assert(status != http::StatusTooManyRequests);

                        if (status == http::StatusNoContent) {
                                api_handler(StatusAPIResponse {status, nullopt, error::NoError});
                        } else if (status == http::StatusConflict) {
                                api_handler(StatusAPIResponse {
                                        status,
                                        nullopt,
                                        MakeError(DeploymentAbortedError, "Could not send status update to server")});
                        } else {
                                auto ex_err_msg = api::ErrorMsgFromErrorResponse(*received_body);
                                string err_str;
                                if (ex_err_msg) {
                                        err_str = ex_err_msg.value();
                                } else {
                                        err_str = resp->GetStatusMessage();
                                }
                                api_handler(StatusAPIResponse {
                                        status,
                                        nullopt,
                                        MakeError(
                                                BadResponseError,
                                                "Got unexpected response " + to_string(status)
                                                        + " from status API: " + err_str)});
                        }
                });
}

void DeploymentClient::PushStatusHeaderHandler(
        shared_ptr<vector<uint8_t>> received_body,
        StatusAPIResponseHandler api_handler,
        http::ExpectedIncomingResponsePtr exp_resp) {
        if (!exp_resp) {
                log::Error("Request to push status data failed: " + exp_resp.error().message);
                api_handler(StatusAPIResponse {nullopt, nullopt, exp_resp.error()});
                return;
        }

        auto body_writer = make_shared<io::ByteWriter>(received_body);
        auto resp = exp_resp.value();
        auto status = resp->GetStatusCode();
        if (status == http::StatusTooManyRequests) {
                StatusAPIResponse response = {
                        status, resp->GetHeaders(), MakeError(TooManyRequestsError, "Too many requests")};
                api_handler(response);
        }
        auto content_length = resp->GetHeader("Content-Length");
        if (!content_length) {
                log::Debug(
                        "Failed to get content length from the deployment status API response headers: "
                        + content_length.error().String());
                body_writer->SetUnlimited(true);
        } else {
                auto ex_len = common::StringTo<size_t>(content_length.value());
                if (!ex_len) {
                        log::Error(
                                "Failed to convert the content length from the deployment status API response headers to an integer: "
                                + ex_len.error().String());
                        body_writer->SetUnlimited(true);
                } else {
                        received_body->resize(ex_len.value());
                }
        }
        resp->SetBodyWriter(body_writer);
}

using mender::common::expected::ExpectedSize;

static ExpectedSize GetLogFileDataSize(const string &path) {
        auto ex_istr = io::OpenIfstream(path);
        if (!ex_istr) {
                return expected::unexpected(ex_istr.error());
        }
        auto istr = std::move(ex_istr.value());

        // We want the size of the actual data without a potential trailing
        // comma. So let's seek one byte before the end of file, check if the last
        // byte is a comma and return the appropriate number.
        istr.seekg(-1, ios_base::end);
        int c = istr.get();
        if (c == ',') {
                return istr.tellg() - static_cast<ifstream::off_type>(1);
        } else {
                return istr.tellg();
        }
}

const vector<uint8_t> JsonLogMessagesReader::header_ = {
        '{', '"', 'm', 'e', 's', 's', 'a', 'g', 'e', 's', '"', ':', '['};
const vector<uint8_t> JsonLogMessagesReader::closing_ = {']', '}'};
const string JsonLogMessagesReader::default_tstamp_ = "1970-01-01T00:00:00.000000000Z";
const string JsonLogMessagesReader::bad_data_msg_tmpl_ =
        R"d({"timestamp": "1970-01-01T00:00:00.000000000Z", "level": "ERROR", "message": "(THE ORIGINAL LOGS CONTAINED INVALID ENTRIES)"},)d";

JsonLogMessagesReader::~JsonLogMessagesReader() {
        reader_.reset();
        if (!sanitized_fpath_.empty() && path::FileExists(sanitized_fpath_)) {
                auto del_err = path::FileDelete(sanitized_fpath_);
                if (del_err != error::NoError) {
                        log::Error("Failed to delete auxiliary logs file: " + del_err.String());
                }
        }
        sanitized_fpath_.erase();
}

static error::Error DoSanitizeLogs(
        const string &orig_path, const string &new_path, bool &all_valid, string &first_tstamp) {
        auto ex_ifs = io::OpenIfstream(orig_path);
        if (!ex_ifs) {
                return ex_ifs.error();
        }
        auto ex_ofs = io::OpenOfstream(new_path);
        if (!ex_ofs) {
                return ex_ofs.error();
        }
        auto &ifs = ex_ifs.value();
        auto &ofs = ex_ofs.value();

        string last_known_tstamp = first_tstamp;
        const string tstamp_prefix_data = R"d({"timestamp": ")d";
        const string corrupt_msg_suffix_data =
                R"d(", "level": "ERROR", "message": "(CORRUPTED LOG DATA)"},)d";

        string line;
        first_tstamp.erase();
        all_valid = true;
        error::Error err;
        while (!ifs.eof()) {
                getline(ifs, line);
                if (!ifs.eof() && !ifs) {
                        int io_errno = errno;
                        return error::Error(
                                generic_category().default_error_condition(io_errno),
                                "Failed to get line from deployment logs file '" + orig_path
                                        + "': " + strerror(io_errno));
                }
                if (line.empty()) {
                        // skip empty lines
                        continue;
                }
                auto ex_json = json::Load(line);
                if (ex_json) {
                        // valid JSON log line, just replace the newline after it with a comma and save the
                        // timestamp for later
                        auto ex_tstamp = ex_json.value().Get("timestamp").and_then(json::ToString);
                        if (ex_tstamp) {
                                if (first_tstamp.empty()) {
                                        first_tstamp = ex_tstamp.value();
                                }
                                last_known_tstamp = std::move(ex_tstamp.value());
                        }
                        line.append(1, ',');
                        err = io::WriteStringIntoOfstream(ofs, line);
                        if (err != error::NoError) {
                                return err.WithContext("Failed to write pre-processed deployment logs data");
                        }
                } else {
                        all_valid = false;
                        if (first_tstamp.empty()) {
                                // If we still don't have the first valid tstamp, we need to
                                // save the last known one (potentially pre-set) as the first
                                // one.
                                first_tstamp = last_known_tstamp;
                        }
                        err = io::WriteStringIntoOfstream(
                                ofs, tstamp_prefix_data + last_known_tstamp + corrupt_msg_suffix_data);
                        if (err != error::NoError) {
                                return err.WithContext("Failed to write pre-processed deployment logs data");
                        }
                }
        }
        return error::NoError;
}

error::Error JsonLogMessagesReader::SanitizeLogs() {
        if (!sanitized_fpath_.empty()) {
                return error::NoError;
        }

        string prep_fpath = log_fpath_ + ".sanitized";
        string first_tstamp = default_tstamp_;
        auto err = DoSanitizeLogs(log_fpath_, prep_fpath, clean_logs_, first_tstamp);
        if (err != error::NoError) {
                if (path::FileExists(prep_fpath)) {
                        auto del_err = path::FileDelete(prep_fpath);
                        if (del_err != error::NoError) {
                                log::Error("Failed to delete auxiliary logs file: " + del_err.String());
                        }
                }
        } else {
                sanitized_fpath_ = std::move(prep_fpath);
                reader_ = make_unique<io::FileReader>(sanitized_fpath_);
                auto ex_sz = GetLogFileDataSize(sanitized_fpath_);
                if (!ex_sz) {
                        return ex_sz.error().WithContext("Failed to determine deployment logs size");
                }
                raw_data_size_ = ex_sz.value();
                rem_raw_data_size_ = raw_data_size_;
                if (!clean_logs_) {
                        auto bad_data_msg_tstamp_start =
                                bad_data_msg_.begin() + 15; // len(R"({"timestamp": ")")
                        copy_n(first_tstamp.cbegin(), first_tstamp.size(), bad_data_msg_tstamp_start);
                }
        }
        return err;
}

error::Error JsonLogMessagesReader::Rewind() {
        AssertOrReturnError(!sanitized_fpath_.empty());
        header_rem_ = header_.size();
        closing_rem_ = closing_.size();
        bad_data_msg_rem_ = bad_data_msg_.size();

        // release/close the file first so that the FileDelete() below can actually
        // delete it and free space up
        reader_.reset();
        auto del_err = path::FileDelete(sanitized_fpath_);
        if (del_err != error::NoError) {
                log::Error("Failed to delete auxiliary logs file: " + del_err.String());
        }
        sanitized_fpath_.erase();
        return SanitizeLogs();
}

int64_t JsonLogMessagesReader::TotalDataSize() {
        assert(!sanitized_fpath_.empty());

        auto ret = raw_data_size_ + header_.size() + closing_.size();
        if (!clean_logs_) {
                ret += bad_data_msg_.size();
        }
        return ret;
}

ExpectedSize JsonLogMessagesReader::Read(
        vector<uint8_t>::iterator start, vector<uint8_t>::iterator end) {
        AssertOrReturnUnexpected(!sanitized_fpath_.empty());

        if (header_rem_ > 0) {
                io::Vsize target_size = end - start;
                auto copy_end = copy_n(
                        header_.begin() + (header_.size() - header_rem_), min(header_rem_, target_size), start);
                auto n_copied = copy_end - start;
                header_rem_ -= n_copied;
                return static_cast<size_t>(n_copied);
        } else if (!clean_logs_ && (bad_data_msg_rem_ > 0)) {
                io::Vsize target_size = end - start;
                auto copy_end = copy_n(
                        bad_data_msg_.begin() + (bad_data_msg_.size() - bad_data_msg_rem_),
                        min(bad_data_msg_rem_, target_size),
                        start);
                auto n_copied = copy_end - start;
                bad_data_msg_rem_ -= n_copied;
                return static_cast<size_t>(n_copied);
        } else if (rem_raw_data_size_ > 0) {
                if (end - start > rem_raw_data_size_) {
                        end = start + static_cast<size_t>(rem_raw_data_size_);
                }
                auto ex_sz = reader_->Read(start, end);
                if (!ex_sz) {
                        return ex_sz;
                }
                auto n_read = ex_sz.value();
                rem_raw_data_size_ -= n_read;

                // We control how much we read from the file so we should never read
                // 0 bytes (meaning EOF reached). If we do, it means the file is
                // smaller than what we were told.
                assert(n_read > 0);
                if (n_read == 0) {
                        return expected::unexpected(
                                MakeError(InvalidDataError, "Unexpected EOF when reading logs file"));
                }
                return n_read;
        } else if (closing_rem_ > 0) {
                io::Vsize target_size = end - start;
                auto copy_end = copy_n(
                        closing_.begin() + (closing_.size() - closing_rem_),
                        min(closing_rem_, target_size),
                        start);
                auto n_copied = copy_end - start;
                closing_rem_ -= n_copied;
                return static_cast<size_t>(copy_end - start);
        } else {
                return 0;
        }
};

static const string logs_uri_suffix = "/log";

error::Error DeploymentClient::PushLogs(
        const string &deployment_id,
        const string &log_file_path,
        api::Client &client,
        LogsAPIResponseHandler api_handler) {
        auto logs_reader = make_shared<JsonLogMessagesReader>(log_file_path);
        auto err = logs_reader->SanitizeLogs();
        if (err != error::NoError) {
                return err;
        }

        auto req = make_shared<api::APIRequest>();
        req->SetPath(http::JoinUrl(deployments_uri_prefix, deployment_id, logs_uri_suffix));
        req->SetMethod(http::Method::PUT);
        req->SetHeader("Content-Type", "application/json");
        req->SetHeader("Content-Length", to_string(logs_reader->TotalDataSize()));
        req->SetHeader("Accept", "application/json");
        req->SetBodyGenerator([logs_reader]() {
                logs_reader->Rewind();
                return logs_reader;
        });

        auto received_body = make_shared<vector<uint8_t>>();
        return client.AsyncCall(
                req,
                [this, received_body, api_handler](http::ExpectedIncomingResponsePtr exp_resp) {
                        this->PushLogsHeaderHandler(received_body, api_handler, exp_resp);
                },
                [received_body, api_handler](http::ExpectedIncomingResponsePtr exp_resp) {
                        if (!exp_resp) {
                                log::Error("Request to push logs data failed: " + exp_resp.error().message);
                                api_handler(LogsAPIResponse {nullopt, nullopt, exp_resp.error()});
                                return;
                        }

                        auto resp = exp_resp.value();
                        auto status = resp->GetStatusCode();

                        // StatusTooManyRequests must have been handled in PushLogsHeaderHandler already
                        assert(status != http::StatusTooManyRequests);
                        // StatusRequestBodyTooLarge must have been handled in PushLogsHeaderHandler already
                        assert(status != http::StatusRequestBodyTooLarge);

                        if (status == http::StatusNoContent) {
                                api_handler(LogsAPIResponse {status, nullopt, error::NoError});
                        } else {
                                auto ex_err_msg = api::ErrorMsgFromErrorResponse(*received_body);
                                string err_str;
                                if (ex_err_msg) {
                                        err_str = ex_err_msg.value();
                                } else {
                                        err_str = resp->GetStatusMessage();
                                }
                                api_handler(LogsAPIResponse {
                                        status,
                                        nullopt,
                                        MakeError(
                                                BadResponseError,
                                                "Got unexpected response " + to_string(status)
                                                        + " from logs API: " + err_str)});
                        }
                });
}

void DeploymentClient::PushLogsHeaderHandler(
        shared_ptr<vector<uint8_t>> received_body,
        LogsAPIResponseHandler api_handler,
        http::ExpectedIncomingResponsePtr exp_resp) {
        if (!exp_resp) {
                log::Error("Request to push logs data failed: " + exp_resp.error().message);
                api_handler(LogsAPIResponse {nullopt, nullopt, exp_resp.error()});
                return;
        }

        auto body_writer = make_shared<io::ByteWriter>(received_body);
        auto resp = exp_resp.value();
        auto status = resp->GetStatusCode();
        if (status == http::StatusTooManyRequests) {
                LogsAPIResponse response = {
                        status, resp->GetHeaders(), MakeError(TooManyRequestsError, "Too many requests")};
                api_handler(response);
        } else if (status == http::StatusRequestBodyTooLarge) {
                LogsAPIResponse response = {
                        status,
                        resp->GetHeaders(),
                        MakeError(RequestBodyTooLargeError, "Could not send logs to server")};
                api_handler(response);
        }
        auto content_length = resp->GetHeader("Content-Length");
        if (!content_length) {
                log::Debug(
                        "Failed to get content length from the deployment log API response headers: "
                        + content_length.error().String());
                body_writer->SetUnlimited(true);
        } else {
                auto ex_len = common::StringTo<size_t>(content_length.value());
                if (!ex_len) {
                        log::Error(
                                "Failed to convert the content length from the deployment log API response headers to an integer: "
                                + ex_len.error().String());
                        body_writer->SetUnlimited(true);
                } else {
                        received_body->resize(ex_len.value());
                }
        }
        resp->SetBodyWriter(body_writer);
}

} // namespace deployments
} // namespace update
} // namespace mender

mendersoftware / mender / 2378429566

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