eric/cariflex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
22db3411a860f7eb4634ea997197209f2eced771
cariflex/tools/EVerest-main/lib/everest/system/src/rauc_dbus_base.cpp
Eric F d398a6ced2 Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter 
- CitrineOS core extracted (CSMS OCPP 2.0.1)
- OpenOCPP extracted (firmware OCPP 1.6J/2.0.1)
- ShapeShifter library installed (pip install -e)
- ShapeShifter specification extracted
- EVerest extracted

TODO updated with progress
2026-06-08 00:38:27 -04:00

474 lines
18 KiB
C++
Raw Blame History

// SPDX-License-Identifier: Apache-2.0
// Copyright Pionix GmbH and Contributors to EVerest
#include <everest/logging.hpp>
#include <everest/system/dbus_base.hpp>
#include <everest/system/rauc_dbus_base.hpp>
#include <everest/system/safe_system.hpp>
#include <string>
#include <string_view>
namespace {
using namespace everest::lib::system;
using namespace everest::lib::system::rauc_dbus;
using namespace everest::lib::system::rauc_dbus::rauc_messages;
sdbus::PendingAsyncCall get_property_async(RaucBase::property_cb handler, const std::unique_ptr<sdbus::IProxy>& proxy,
const char* property, const char* interface) {
sdbus::PendingAsyncCall result;
try {
result = dbus::getPropertyAsync(proxy, handler, property, interface);
} catch (const sdbus::Error& e) {
EVLOG_error << "getPropertyAsync '" << property << "': " << e.what();
}
return result;
}
sdbus::PendingAsyncCall call_method_async(RaucBase::method_cb handler, const std::unique_ptr<sdbus::IProxy>& proxy,
const char* interface, const char* method, uint64_t timeout_us) {
sdbus::PendingAsyncCall result;
try {
auto m = dbus::createMethodCall(proxy, interface, method);
result = dbus::callMethodAsync(proxy, m, handler, timeout_us);
} catch (const sdbus::Error& e) {
EVLOG_error << "callMethodAsync '" << method << "': " << e.what();
}
return result;
}
template <typename T>
CmdResult get_property(T& result, const std::unique_ptr<sdbus::IProxy>& proxy, const char* property,
const char* interface) {
CmdResult res{false, {}};
try {
result = proxy->getProperty(property).onInterface(interface).get<T>();
res.success = true;
} catch (const sdbus::Error& e) {
EVLOG_error << "getProperty '" << property << "': " << e.what();
res.error_msg = e.getMessage();
}
return res;
}
template <typename T>
CmdResult call_method(T& result, const std::unique_ptr<sdbus::IProxy>& proxy, sdbus::MethodCall& method,
const char* m_str, uint64_t timeout_us) {
CmdResult res{false, {}};
try {
auto reply = proxy->callMethod(method, timeout_us);
if (!reply.isEmpty()) {
reply >> result;
res.success = true;
}
} catch (const sdbus::Error& e) {
EVLOG_error << "callMethod '" << m_str << "': " << e.what();
res.error_msg = e.getMessage();
}
return res;
}
CmdResult call_method(const std::unique_ptr<sdbus::IProxy>& proxy, sdbus::MethodCall& method, const char* m_str,
uint64_t timeout_us) {
CmdResult res{false, {}};
try {
proxy->callMethod(method, timeout_us);
res.success = true;
} catch (const sdbus::Error& e) {
EVLOG_error << "callMethod '" << m_str << "': " << e.what();
res.error_msg = e.getMessage();
}
return res;
}
} // namespace
namespace everest::lib::system::rauc_dbus {
namespace rauc_messages {
sdbus::Message& operator<<(sdbus::Message& msg, const Progress& items) {
return msg << sdbus::Struct{std::forward_as_tuple(items.percent, items.description, items.level)};
}
sdbus::Message& operator>>(sdbus::Message& msg, Progress& items) {
sdbus::Struct s{std::forward_as_tuple(items.percent, items.description, items.level)};
return msg >> s;
}
Operation string_to_operation(const std::string_view& s) {
if (s == "idle") {
return rauc_messages::Operation::Idle;
}
if (s == "installing") {
return rauc_messages::Operation::Installing;
}
if (!s.empty()) {
EVLOG_warning << "Unknown rauc operation: " << s;
}
return rauc_messages::Operation::Unknown;
}
} // namespace rauc_messages
// ----------------------------------------------------------------------------
// class RaucBase
RaucBase::RaucBase() {
// Create proxy object, this will start an internal event loop thread
proxy = dbus::createProxy(defaults::service_domain, defaults::object_path);
}
RaucBase::RaucBase(sdbus::dont_run_event_loop_thread_t) {
// Create proxy object, using an external event loop
proxy = dbus::createProxy(defaults::service_domain, defaults::object_path, sdbus::dont_run_event_loop_thread);
}
void RaucBase::configure(const std::string& verify_update_script_path) {
this->verify_update_script_path = verify_update_script_path;
try {
dbus::initialise_handlers(proxy, [this]() { configure_handlers(); });
} catch (const sdbus::Error& e) {
EVLOG_error << "RaucBase::configure: " << e.getMessage();
}
}
// Call on boot and pass a previous transaction that was not closed yet
bool RaucBase::check_previous_transaction(const CurrentState& current, const rauc_messages::UpdateTransaction& saved) {
bool result{false};
const std::string state = "boot=" + current.boot_slot + " primary=" + current.primary_slot;
const std::string transaction = "transaction boot=" + saved.boot_slot + " primary=" + saved.primary_slot +
" id=" + std::to_string(saved.request_id);
if (decide_if_good(saved, current)) {
EVLOG_info << "We have booted into the new updated slot (" << state << "), update was successful ("
<< transaction << ") Marking good";
// Mark this slot as good in RAUC
result = true;
} else {
EVLOG_error << "We have booted into the old fall back slot (" << state << "), update was not successful ("
<< transaction << ')';
}
return result;
}
sdbus::PendingAsyncCall RaucBase::get_boot_slot(property_cb handler) const {
return get_property_async(handler, proxy, property::BootSlot, interface::Installer);
}
sdbus::PendingAsyncCall RaucBase::install_bundle(method_cb handler, const std::string& filename, uint64_t timeout_us) {
sdbus::PendingAsyncCall result;
try {
auto method = dbus::createMethodCall(proxy, interface::Installer, method::InstallBundle);
std::map<std::string, sdbus::Variant> parameters;
method << filename << parameters;
result = dbus::callMethodAsync(proxy, method, handler, timeout_us);
} catch (const sdbus::Error& e) {
EVLOG_error << "RaucBase::install_bundle: " << e.what();
}
return result;
}
sdbus::PendingAsyncCall RaucBase::mark(method_cb handler, const std::string& mark, const std::string& slot,
uint64_t timeout_us) {
sdbus::PendingAsyncCall result;
try {
auto method = dbus::createMethodCall(proxy, interface::Installer, method::Mark);
method << mark << slot;
result = dbus::callMethodAsync(proxy, method, handler, timeout_us);
} catch (const sdbus::Error& e) {
EVLOG_error << "RaucBase::mark: " << e.what();
}
return result;
}
RaucBase::slot_info_t RaucBase::convert(slots_t& slots) {
slot_info_t result;
for (const auto& [n, v] : slots) {
std::map<std::string, std::string> nv_dict;
for (const auto& [nn, vv] : v) {
try {
if (nn == "size") {
nv_dict[nn] = std::to_string(vv.get<std::uint64_t>());
} else if (nn == "installed.count") {
nv_dict[nn] = std::to_string(vv.get<std::uint32_t>());
} else {
nv_dict[nn] = vv.get<std::string>();
}
} catch (...) {
nv_dict[nn] = {};
}
}
result[n] = std::move(nv_dict);
}
return result;
}
rauc_messages::HealthCheckStatus RaucBase::check_system_health() {
// checking the success or failure of an OTA update following reboot
using namespace rauc_messages;
if (verify_update_script_path.empty()) {
return HealthCheckStatus::ScriptNotSet;
}
if (access(verify_update_script_path.c_str(), X_OK) != 0) {
EVLOG_error << "Health check script '" << verify_update_script_path << "' not executable";
return HealthCheckStatus::ScriptNotExecutable;
}
const auto res = everest::lib::system::safe_system(verify_update_script_path, {verify_update_script_path});
switch (res.status) {
case everest::lib::system::CMD_SETUP_FAILED:
EVLOG_error << "Health check script '" << verify_update_script_path << "' setup failed, errno: " << res.code;
return HealthCheckStatus::SetupFailed;
case everest::lib::system::CMD_TERMINATED:
EVLOG_error << "Health check script '" << verify_update_script_path << "' terminated by signal: " << res.code;
return HealthCheckStatus::ScriptTerminatedBySignal;
case everest::lib::system::CMD_SUCCESS:
if (res.code == 0) {
EVLOG_debug << "Health check script '" << verify_update_script_path << "' returned success";
return HealthCheckStatus::Success;
} else {
EVLOG_error << "Health check script '" << verify_update_script_path
<< "' returned error code: " << res.code;
return HealthCheckStatus::ScriptExitedWithError;
}
}
// Should not reach here
return HealthCheckStatus::UnknownError;
}
sdbus::PendingAsyncCall RaucBase::get_operation(property_cb handler) const {
return get_property_async(handler, proxy, property::Operation, interface::Installer);
}
sdbus::PendingAsyncCall RaucBase::get_last_error(property_cb handler) const {
return get_property_async(handler, proxy, property::LastError, interface::Installer);
}
sdbus::PendingAsyncCall RaucBase::get_primary_slot(method_cb handler, uint64_t timeout_us) {
return call_method_async(handler, proxy, interface::Installer, method::GetPrimary, timeout_us);
}
sdbus::PendingAsyncCall RaucBase::get_slot_status(method_cb handler, uint64_t timeout_us) {
return call_method_async(handler, proxy, interface::Installer, method::GetSlotStatus, timeout_us);
}
sdbus::PendingAsyncCall RaucBase::get_progress(property_cb handler) const {
return get_property_async(handler, proxy, property::Progress, interface::Installer);
}
bool RaucBase::decide_if_good(const rauc_messages::UpdateTransaction& saved, const CurrentState& current) {
// check that the boot slot has changed and update script ran successfully or was not set
if (saved.boot_slot == current.boot_slot) {
return false;
}
if (current.system_health_rc != rauc_messages::HealthCheckStatus::Success and
current.system_health_rc != rauc_messages::HealthCheckStatus::ScriptNotSet) {
return false;
}
return true;
}
// ----------------------------------------------------------------------------
// class RaucBaseSync
rauc_messages::UpdateTransaction RaucBaseSync::create_transaction(std::int32_t request_id, uint64_t timeout_us) {
return {request_id, get_boot_slot(), get_primary_slot(timeout_us)};
}
bool RaucBaseSync::check_previous_transaction(const rauc_messages::UpdateTransaction& saved, uint64_t timeout_us) {
const CurrentState current{check_system_health(), get_boot_slot(), get_primary_slot(timeout_us)};
const auto res = RaucBase::check_previous_transaction(current, saved);
if (res) {
mark("good", "booted", timeout_us);
}
return res;
}
rauc_messages::CmdResult RaucBaseSync::install_bundle(const std::string& filename, uint64_t timeout_us) {
auto method = dbus::createMethodCall(proxy, interface::Installer, method::InstallBundle);
std::map<std::string, sdbus::Variant> parameters;
method << filename << parameters;
return call_method(proxy, method, method::InstallBundle, timeout_us);
}
void RaucBaseSync::mark(const std::string& mark, const std::string& slot, uint64_t timeout_us) {
auto method = dbus::createMethodCall(proxy, interface::Installer, method::Mark);
method << mark << slot;
call_method(proxy, method, method::Mark, timeout_us);
}
std::string RaucBaseSync::get_boot_slot() const {
std::string result;
get_property(result, proxy, property::BootSlot, interface::Installer);
return result;
}
std::string RaucBaseSync::get_primary_slot(uint64_t timeout_us) {
std::string result;
auto method = dbus::createMethodCall(proxy, interface::Installer, method::GetPrimary);
call_method(result, proxy, method, method::GetPrimary, timeout_us);
return result;
}
std::map<std::string, std::map<std::string, std::string>> RaucBaseSync::get_slot_status(uint64_t timeout_us) {
// a(sa{sv})
slots_t slots;
auto method = dbus::createMethodCall(proxy, interface::Installer, method::GetSlotStatus);
call_method(slots, proxy, method, method::GetSlotStatus, timeout_us);
return convert(slots);
}
std::string RaucBaseSync::get_last_error() const {
std::string result;
get_property(result, proxy, property::LastError, interface::Installer);
return result;
}
rauc_messages::Operation RaucBaseSync::get_operation() const {
std::string result;
get_property(result, proxy, property::Operation, interface::Installer);
return rauc_messages::string_to_operation(result);
}
rauc_messages::Progress RaucBaseSync::get_progress() const {
rauc_messages::Progress result{0, {}, 0};
get_property(result, proxy, property::Progress, interface::Installer);
return result;
}
// ----------------------------------------------------------------------------
// class RaucBaseAsync
bool RaucBaseAsync::install_bundle(const std::string& filename, uint64_t timeout_us) {
auto handler = [this](sdbus::MethodReply reply, std::optional<sdbus::Error> error) {
if (error) {
cb_error(error_t::install_bundle, error->getMessage());
} else {
cb_install_bundle();
}
};
active_request = RaucBase::install_bundle(handler, filename, timeout_us);
return active_request.isPending();
}
bool RaucBaseAsync::mark(const std::string& mark, const std::string& slot, uint64_t timeout_us) {
auto handler = [this](sdbus::MethodReply reply, std::optional<sdbus::Error> error) {
if (error) {
cb_error(error_t::mark, error->getMessage());
} else {
cb_mark();
}
};
active_request = RaucBase::mark(handler, mark, slot, timeout_us);
return active_request.isPending();
}
bool RaucBaseAsync::get_boot_slot() {
auto handler = [this](std::optional<sdbus::Error> error, sdbus::Variant value) {
if (error) {
cb_error(error_t::boot_slot, error.value().getMessage());
} else {
try {
cb_boot_slot(value.get<std::string>());
} catch (const sdbus::Error& e) {
std::string e_str = "Exception: " + e.getMessage();
cb_error(error_t::boot_slot, e_str);
}
}
};
active_request = RaucBase::get_boot_slot(handler);
return active_request.isPending();
}
bool RaucBaseAsync::get_primary_slot(uint64_t timeout_us) {
auto handler = [this](sdbus::MethodReply reply, std::optional<sdbus::Error> error) {
if (error) {
cb_error(error_t::primary_slot, error->getMessage());
} else {
try {
std::string slot;
reply >> slot;
cb_primary_slot(slot);
} catch (const sdbus::Error& e) {
std::string e_str = "Exception: " + e.getMessage();
cb_error(error_t::primary_slot, e_str);
}
}
};
active_request = RaucBase::get_primary_slot(handler, timeout_us);
return active_request.isPending();
}
bool RaucBaseAsync::get_slot_status(uint64_t timeout_us) {
auto handler = [this](sdbus::MethodReply reply, std::optional<sdbus::Error> error) {
if (error) {
cb_error(error_t::slot_status, error->getMessage());
} else {
try {
slots_t slots;
reply >> slots;
cb_slot_status(convert(slots));
} catch (const sdbus::Error& e) {
std::string e_str = "Exception: " + e.getMessage();
cb_error(error_t::slot_status, e_str);
}
}
};
active_request = RaucBase::get_slot_status(handler, timeout_us);
return active_request.isPending();
}
bool RaucBaseAsync::get_last_error() {
auto handler = [this](std::optional<sdbus::Error> error, sdbus::Variant value) {
if (error) {
cb_error(error_t::last_error, error.value().getMessage());
} else {
try {
cb_last_error(value.get<std::string>());
} catch (const sdbus::Error& e) {
std::string e_str = "Exception: " + e.getMessage();
cb_error(error_t::last_error, e_str);
}
}
};
active_request = RaucBase::get_last_error(handler);
return active_request.isPending();
}
bool RaucBaseAsync::get_operation() {
auto handler = [this](std::optional<sdbus::Error> error, sdbus::Variant value) {
if (error) {
cb_error(error_t::operation, error.value().getMessage());
} else {
try {
cb_operation(string_to_operation(value.get<std::string>()));
} catch (const sdbus::Error& e) {
std::string e_str = "Exception: " + e.getMessage();
cb_error(error_t::operation, e_str);
}
}
};
active_request = RaucBase::get_operation(handler);
return active_request.isPending();
}
bool RaucBaseAsync::get_progress() {
auto handler = [this](std::optional<sdbus::Error> error, sdbus::Variant value) {
if (error) {
cb_error(error_t::progress, error.value().getMessage());
} else {
try {
cb_progress(value.get<rauc_messages::Progress>());
} catch (const sdbus::Error& e) {
std::string e_str = "Exception: " + e.getMessage();
cb_error(error_t::progress, e_str);
}
}
};
active_request = RaucBase::get_progress(handler);
return active_request.isPending();
}
} // namespace everest::lib::system::rauc_dbus
Reference in New Issue View Git Blame Copy Permalink