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
This commit is contained in:
Eric F
473
tools/EVerest-main/lib/everest/system/src/rauc_dbus_base.cpp
Normal file
473
tools/EVerest-main/lib/everest/system/src/rauc_dbus_base.cpp
Normal file
@@ -0,0 +1,473 @@
|
||||
// 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
Block a user