| #include <sysrepo-cpp/utils/exception.hpp> |
| #include "trompeloeil_doctest.h" |
| #include "dbus-helpers/dbus_rauc_server.h" |
| #include "pretty_printers.h" |
| #include "system/Firmware.h" |
| #include "test_log_setup.h" |
| #include "tests/configure.cmake.h" |
| #include "tests/sysrepo-helpers/common.h" |
| #include "tests/sysrepo-helpers/notifications.h" |
| |
| using namespace std::literals; |
| |
| std::vector<std::unique_ptr<trompeloeil::expectation>> expectationFactory(const DBusRAUCServer::InstallBehaviour& installType, NotificationWatcher& eventMock, trompeloeil::sequence& seq1) |
| { |
| std::vector<std::unique_ptr<trompeloeil::expectation>> expectations; |
| |
| auto progressData = [](int progress, std::string message) { |
| return Values{ |
| {"progress", std::to_string(progress)}, |
| {"message", message}, |
| }; |
| }; |
| |
| if (installType == DBusRAUCServer::InstallBehaviour::OK) { |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(0, "Installing"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(0, "Determining slot states"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(20, "Determining slot states done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(20, "Checking bundle"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(20, "Veryfing signature"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(40, "Veryfing signature done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(40, "Checking bundle done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(40, "Loading manifest file"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(60, "Loading manifest file done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(60, "Determining target install group"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(80, "Determining target install group done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(80, "Updating slots"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(80, "Checking slot rootfs.0"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(85, "Checking slot rootfs.0 done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(85, "Copying image to rootfs.0"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(90, "Copying image to rootfs.0 done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(90, "Checking slot cfg.0"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(95, "Checking slot cfg.0 done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(95, "Copying image to cfg.0"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(100, "Copying image to cfg.0 done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(100, "Updating slots done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(100, "Installing done."))).IN_SEQUENCE(seq1)); |
| } else { |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(0, "Installing"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(0, "Determining slot states"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(20, "Determining slot states done."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(20, "Checking bundle"))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(40, "Checking bundle failed."))).IN_SEQUENCE(seq1)); |
| expectations.push_back(NAMED_REQUIRE_CALL(eventMock, notified(progressData(100, "Installing failed."))).IN_SEQUENCE(seq1)); |
| } |
| |
| return expectations; |
| } |
| |
| |
| TEST_CASE("Firmware in czechlight-system, RPC") |
| { |
| trompeloeil::sequence seq1; |
| |
| TEST_SYSREPO_INIT_LOGS; |
| TEST_SYSREPO_INIT; |
| TEST_SYSREPO_INIT_CLIENT; |
| |
| auto dbusServerConnection = sdbus::createSessionBusConnection("de.pengutronix.rauc"); |
| auto dbusClientConnectionSignals = sdbus::createSessionBusConnection(); |
| auto dbusClientConnectionMethods = sdbus::createSessionBusConnection(); |
| dbusClientConnectionSignals->enterEventLoopAsync(); |
| dbusClientConnectionMethods->enterEventLoopAsync(); |
| dbusServerConnection->enterEventLoopAsync(); |
| |
| std::map<std::string, velia::system::RAUC::SlotProperties> dbusRaucStatus = { |
| {"rootfs.1", { |
| {"activated.count", uint32_t {39}}, |
| {"activated.timestamp", "2021-01-13T17:20:18Z"}, |
| {"bootname", "B"}, |
| {"boot-status", "good"}, |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-103-g34d2f48"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p3"}, |
| {"installed.count", uint32_t {39}}, |
| {"installed.timestamp", "2021-01-13T17:20:15Z"}, |
| {"mountpoint", "/"}, |
| {"sha256", "07b30d065c7aad64d2006ce99fd339c929d3ca97b666fca4584b9ef726469fc4"}, |
| {"size", uint64_t {45601892}}, |
| {"state", "booted"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"rootfs.0", { |
| {"activated.count", uint32_t {41}}, |
| {"activated.timestamp", "2021-01-13T17:15:54Z"}, |
| {"bootname", "A"}, |
| {"boot-status", "bad"}, |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-104-ge80fcd4"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p1"}, |
| {"installed.count", uint32_t {41}}, |
| {"installed.timestamp", "2021-01-13T17:15:50Z"}, |
| {"sha256", "6d81e8f341edd17c127811f7347c7e23d18c2fc25c0bdc29ac56999cc9c25629"}, |
| {"size", uint64_t {45647664}}, |
| {"state", "inactive"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"cfg.1", { |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-103-g34d2f48"}, |
| {"class", "cfg"}, |
| {"device", "/dev/mmcblk0p4"}, |
| {"installed.count", uint32_t {39}}, |
| {"installed.timestamp", "2021-01-13T17:20:18Z"}, |
| {"mountpoint", "/cfg"}, |
| {"parent", "rootfs.1"}, |
| {"sha256", "5ca1b6c461fc194055d52b181f57c63dc1d34c19d041f6395e6f6abc039692bb"}, |
| {"size", uint64_t {108}}, |
| {"state", "active"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"cfg.0", { |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-104-ge80fcd4"}, |
| {"class", "cfg"}, |
| {"device", "/dev/mmcblk0p2"}, |
| {"installed.count", uint32_t {41}}, |
| {"installed.timestamp", "2021-01-13T17:15:54Z"}, |
| {"parent", "rootfs.0"}, |
| {"sha256", "5ca1b6c461fc194055d52b181f57c63dc1d34c19d041f6395e6f6abc039692bb"}, |
| {"size", uint64_t {108}}, |
| {"state", "inactive"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| }; |
| auto raucServer = DBusRAUCServer(*dbusServerConnection, "rootfs.1", dbusRaucStatus); |
| auto sysrepo = std::make_shared<velia::system::Firmware>(srConn, *dbusClientConnectionSignals, *dbusClientConnectionMethods); |
| |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware", sysrepo::Datastore::Operational) == std::map<std::string, std::string> { |
| {"/firmware-slot[name='A']", ""}, |
| {"/firmware-slot[name='A']/is-healthy", "false"}, |
| {"/firmware-slot[name='A']/installed", "2021-01-13T17:15:50-00:00"}, |
| {"/firmware-slot[name='A']/name", "A"}, |
| {"/firmware-slot[name='A']/is-booted-now", "false"}, |
| {"/firmware-slot[name='A']/version", "v4-104-ge80fcd4"}, |
| {"/firmware-slot[name='A']/will-boot-next", "false"}, |
| {"/firmware-slot[name='B']", ""}, |
| {"/firmware-slot[name='B']/is-healthy", "true"}, |
| {"/firmware-slot[name='B']/installed", "2021-01-13T17:20:15-00:00"}, |
| {"/firmware-slot[name='B']/name", "B"}, |
| {"/firmware-slot[name='B']/is-booted-now", "true"}, |
| {"/firmware-slot[name='B']/version", "v4-103-g34d2f48"}, |
| {"/firmware-slot[name='B']/will-boot-next", "true"}, |
| {"/installation", ""}, |
| {"/installation/message", ""}, |
| {"/installation/status", "none"}, |
| }); |
| |
| SECTION("Firmware install RPC") |
| { |
| auto rpcInput = client.getContext().newPath("/czechlight-system:firmware/installation/install/url", "/path/to/bundle/update.raucb"); |
| |
| SECTION("Installation runs") |
| { |
| NotificationWatcher installProgressMock{client, "/czechlight-system:firmware/installation/update"}; |
| DBusRAUCServer::InstallBehaviour installType; |
| std::map<std::string, std::string> expectedFinished, expectedInProgress = { |
| {"/message", ""}, |
| {"/status", "in-progress"}, |
| }; |
| |
| SECTION("Successfull install") |
| { |
| installType = DBusRAUCServer::InstallBehaviour::OK; |
| expectedFinished = { |
| {"/message", ""}, |
| {"/status", "succeeded"}, |
| }; |
| } |
| |
| SECTION("Unsuccessfull install") |
| { |
| installType = DBusRAUCServer::InstallBehaviour::FAILURE; |
| expectedFinished = { |
| {"/message", "Failed to download bundle https://10.88.3.11:8000/update.raucb: Transfer failed: error:1408F10B:SSL routines:ssl3_get_record:wrong version number"}, |
| {"/status", "failed"}, |
| }; |
| } |
| |
| raucServer.installBundleBehaviour(installType); |
| auto progressExpectations = expectationFactory(installType, installProgressMock, seq1); |
| auto res = client.sendRPC(rpcInput); |
| REQUIRE(res.child() == std::nullopt); |
| |
| std::this_thread::sleep_for(10ms); // lets wait a while, so the RAUC's callback for operation changed takes place |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware/installation", sysrepo::Datastore::Operational) == expectedInProgress); |
| |
| waitForCompletionAndBitMore(seq1); // wait for installation to complete |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware/installation", sysrepo::Datastore::Operational) == expectedFinished); |
| } |
| |
| SECTION("Unsuccessfull install followed by successfull install") |
| { |
| NotificationWatcher installProgressMock{client, "/czechlight-system:firmware/installation/update"}; |
| // invoke unsuccessfull install |
| { |
| raucServer.installBundleBehaviour(DBusRAUCServer::InstallBehaviour::FAILURE); |
| auto progressExpectations = expectationFactory(DBusRAUCServer::InstallBehaviour::FAILURE, installProgressMock, seq1); |
| client.sendRPC(rpcInput); |
| |
| waitForCompletionAndBitMore(seq1); // wait for installation to complete |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware/installation", sysrepo::Datastore::Operational) == std::map<std::string, std::string> { |
| {"/message", "Failed to download bundle https://10.88.3.11:8000/update.raucb: Transfer failed: error:1408F10B:SSL routines:ssl3_get_record:wrong version number"}, |
| {"/status", "failed"}, |
| }); |
| } |
| |
| // invoke successfull install |
| { |
| raucServer.installBundleBehaviour(DBusRAUCServer::InstallBehaviour::OK); |
| auto progressExpectations = expectationFactory(DBusRAUCServer::InstallBehaviour::OK, installProgressMock, seq1); |
| client.sendRPC(rpcInput); |
| |
| std::this_thread::sleep_for(10ms); // lets wait a while, so the RAUC's callback for operation changed takes place |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware/installation", sysrepo::Datastore::Operational) == std::map<std::string, std::string> { |
| {"/message", ""}, |
| {"/status", "in-progress"}, |
| }); |
| |
| waitForCompletionAndBitMore(seq1); // wait for installation to complete |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware/installation", sysrepo::Datastore::Operational) == std::map<std::string, std::string>{ |
| {"/message", ""}, |
| {"/status", "succeeded"}, |
| }); |
| } |
| } |
| |
| SECTION("Installation in progress") |
| { |
| raucServer.installBundleBehaviour(DBusRAUCServer::InstallBehaviour::OK); |
| client.sendRPC(rpcInput); |
| std::this_thread::sleep_for(10ms); |
| |
| SECTION("Invoking second installation throws") |
| { |
| REQUIRE_THROWS_WITH_AS(client.sendRPC(rpcInput), |
| "Couldn't send RPC: SR_ERR_CALLBACK_FAILED\n" |
| // FIXME: why is this present twice? Looks like a libyang-v2.2/sysrepo change that I do not understand |
| " Already processing a different method (SR_ERR_OPERATION_FAILED)\n" |
| " Already processing a different method (SR_ERR_OPERATION_FAILED)\n" |
| " User callback failed. (SR_ERR_CALLBACK_FAILED)\n" |
| " NETCONF: application: operation-failed: Already processing a different method", |
| sysrepo::ErrorWithCode); |
| } |
| |
| SECTION("Firmware slot data are available") |
| { |
| // RAUC does not respond to GetSlotStatus when another operation in progress, so let's check we use the cached data |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware", sysrepo::Datastore::Operational) == std::map<std::string, std::string> { |
| {"/firmware-slot[name='A']", ""}, |
| {"/firmware-slot[name='A']/is-healthy", "false"}, |
| {"/firmware-slot[name='A']/installed", "2021-01-13T17:15:50-00:00"}, |
| {"/firmware-slot[name='A']/name", "A"}, |
| {"/firmware-slot[name='A']/is-booted-now", "false"}, |
| {"/firmware-slot[name='A']/version", "v4-104-ge80fcd4"}, |
| {"/firmware-slot[name='A']/will-boot-next", "false"}, |
| {"/firmware-slot[name='B']", ""}, |
| {"/firmware-slot[name='B']/is-healthy", "true"}, |
| {"/firmware-slot[name='B']/installed", "2021-01-13T17:20:15-00:00"}, |
| {"/firmware-slot[name='B']/name", "B"}, |
| {"/firmware-slot[name='B']/is-booted-now", "true"}, |
| {"/firmware-slot[name='B']/version", "v4-103-g34d2f48"}, |
| {"/firmware-slot[name='B']/will-boot-next", "true"}, |
| {"/installation", ""}, |
| {"/installation/message", ""}, |
| {"/installation/status", "in-progress"}, |
| }); |
| } |
| } |
| } |
| |
| SECTION("marking FW slots") { |
| auto rpcInput = client.getContext().newPath("/czechlight-system:firmware/firmware-slot[name='A']/set-active-after-reboot"); |
| { |
| REQUIRE_CALL(raucServer, impl_Mark("active", "rootfs.0")).IN_SEQUENCE(seq1); |
| REQUIRE(client.sendRPC(rpcInput).child() == std::nullopt); |
| } |
| |
| rpcInput = client.getContext().newPath("/czechlight-system:firmware/firmware-slot[name='B']/set-active-after-reboot"); |
| { |
| REQUIRE_CALL(raucServer, impl_Mark("active", "rootfs.1")).IN_SEQUENCE(seq1); |
| REQUIRE(client.sendRPC(rpcInput).child() == std::nullopt); |
| } |
| |
| rpcInput = client.getContext().newPath("/czechlight-system:firmware/firmware-slot[name='B']/set-unhealthy"); |
| { |
| REQUIRE_CALL(raucServer, impl_Mark("bad", "rootfs.1")).IN_SEQUENCE(seq1); |
| REQUIRE(client.sendRPC(rpcInput).child() == std::nullopt); |
| } |
| |
| waitForCompletionAndBitMore(seq1); |
| } |
| } |
| |
| TEST_CASE("Firmware in czechlight-system, slot status") |
| { |
| trompeloeil::sequence seq1; |
| |
| TEST_SYSREPO_INIT_LOGS; |
| TEST_SYSREPO_INIT; |
| TEST_SYSREPO_INIT_CLIENT; |
| |
| auto dbusServerConnection = sdbus::createSessionBusConnection("de.pengutronix.rauc"); |
| auto dbusClientConnectionSignals = sdbus::createSessionBusConnection(); |
| auto dbusClientConnectionMethods = sdbus::createSessionBusConnection(); |
| dbusClientConnectionSignals->enterEventLoopAsync(); |
| dbusClientConnectionMethods->enterEventLoopAsync(); |
| dbusServerConnection->enterEventLoopAsync(); |
| |
| std::map<std::string, velia::system::RAUC::SlotProperties> dbusRaucStatus; |
| std::map<std::string, std::string> expected; |
| |
| SECTION("Complete data") |
| { |
| dbusRaucStatus = { |
| {"rootfs.1", { |
| {"activated.count", uint32_t {39}}, |
| {"activated.timestamp", "2021-01-13T17:20:18Z"}, |
| {"bootname", "B"}, |
| {"boot-status", "good"}, |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-103-g34d2f48"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p3"}, |
| {"installed.count", uint32_t {39}}, |
| {"installed.timestamp", "2021-01-13T17:20:15Z"}, |
| {"mountpoint", "/"}, |
| {"sha256", "07b30d065c7aad64d2006ce99fd339c929d3ca97b666fca4584b9ef726469fc4"}, |
| {"size", uint64_t {45601892}}, |
| {"state", "booted"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"rootfs.0", { |
| {"activated.count", uint32_t {41}}, |
| {"activated.timestamp", "2021-01-13T17:15:54Z"}, |
| {"bootname", "A"}, |
| {"boot-status", "bad"}, |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-104-ge80fcd4"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p1"}, |
| {"installed.count", uint32_t {41}}, |
| {"installed.timestamp", "2021-01-13T17:15:50Z"}, |
| {"sha256", "6d81e8f341edd17c127811f7347c7e23d18c2fc25c0bdc29ac56999cc9c25629"}, |
| {"size", uint64_t {45647664}}, |
| {"state", "inactive"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"cfg.1", { |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-103-g34d2f48"}, |
| {"class", "cfg"}, |
| {"device", "/dev/mmcblk0p4"}, |
| {"installed.count", uint32_t {39}}, |
| {"installed.timestamp", "2021-01-13T17:20:18Z"}, |
| {"mountpoint", "/cfg"}, |
| {"parent", "rootfs.1"}, |
| {"sha256", "5ca1b6c461fc194055d52b181f57c63dc1d34c19d041f6395e6f6abc039692bb"}, |
| {"size", uint64_t {108}}, |
| {"state", "active"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"cfg.0", { |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-104-ge80fcd4"}, |
| {"class", "cfg"}, |
| {"device", "/dev/mmcblk0p2"}, |
| {"installed.count", uint32_t {41}}, |
| {"installed.timestamp", "2021-01-13T17:15:54Z"}, |
| {"parent", "rootfs.0"}, |
| {"sha256", "5ca1b6c461fc194055d52b181f57c63dc1d34c19d041f6395e6f6abc039692bb"}, |
| {"size", uint64_t {108}}, |
| {"state", "inactive"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| }; |
| |
| expected = { |
| {"[name='A']", ""}, |
| {"[name='A']/is-healthy", "false"}, |
| {"[name='A']/installed", "2021-01-13T17:15:50-00:00"}, |
| {"[name='A']/name", "A"}, |
| {"[name='A']/is-booted-now", "false"}, |
| {"[name='A']/version", "v4-104-ge80fcd4"}, |
| {"[name='A']/will-boot-next", "false"}, |
| {"[name='B']", ""}, |
| {"[name='B']/is-healthy", "true"}, |
| {"[name='B']/installed", "2021-01-13T17:20:15-00:00"}, |
| {"[name='B']/name", "B"}, |
| {"[name='B']/is-booted-now", "true"}, |
| {"[name='B']/version", "v4-103-g34d2f48"}, |
| {"[name='B']/will-boot-next", "true"}, |
| }; |
| } |
| |
| SECTION("Missing data in rootfs.0") |
| { |
| dbusRaucStatus = { |
| {"rootfs.1", { |
| {"activated.count", uint32_t {39}}, |
| {"activated.timestamp", "2021-01-13T17:20:18Z"}, |
| {"bootname", "B"}, |
| {"boot-status", "good"}, |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-103-g34d2f48"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p3"}, |
| {"installed.count", uint32_t {39}}, |
| {"installed.timestamp", "2021-01-13T17:20:15Z"}, |
| {"mountpoint", "/"}, |
| {"sha256", "07b30d065c7aad64d2006ce99fd339c929d3ca97b666fca4584b9ef726469fc4"}, |
| {"size", uint64_t {45601892}}, |
| {"state", "booted"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"rootfs.0", { |
| {"bootname", "A"}, |
| {"boot-status", "bad"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p1"}, |
| {"sha256", "6d81e8f341edd17c127811f7347c7e23d18c2fc25c0bdc29ac56999cc9c25629"}, |
| {"size", uint64_t {45647664}}, |
| {"state", "inactive"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| }; |
| |
| expected = { |
| {"[name='A']", ""}, |
| {"[name='A']/is-healthy", "false"}, |
| {"[name='A']/name", "A"}, |
| {"[name='A']/is-booted-now", "false"}, |
| {"[name='A']/will-boot-next", "false"}, |
| {"[name='B']", ""}, |
| {"[name='B']/is-healthy", "true"}, |
| {"[name='B']/installed", "2021-01-13T17:20:15-00:00"}, |
| {"[name='B']/name", "B"}, |
| {"[name='B']/is-booted-now", "true"}, |
| {"[name='B']/version", "v4-103-g34d2f48"}, |
| {"[name='B']/will-boot-next", "true"}, |
| }; |
| } |
| |
| SECTION("Missing bootname in rootfs.0") |
| { |
| dbusRaucStatus = { |
| {"rootfs.1", { |
| {"activated.count", uint32_t {39}}, |
| {"activated.timestamp", "2021-01-13T17:20:18Z"}, |
| {"bootname", "B"}, |
| {"boot-status", "good"}, |
| {"bundle.compatible", "czechlight-clearfog"}, |
| {"bundle.version", "v4-103-g34d2f48"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p3"}, |
| {"installed.count", uint32_t {39}}, |
| {"installed.timestamp", "2021-01-13T17:20:15Z"}, |
| {"mountpoint", "/"}, |
| {"sha256", "07b30d065c7aad64d2006ce99fd339c929d3ca97b666fca4584b9ef726469fc4"}, |
| {"size", uint64_t {45601892}}, |
| {"state", "booted"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| {"rootfs.0", { |
| {"boot-status", "bad"}, |
| {"class", "rootfs"}, |
| {"device", "/dev/mmcblk0p1"}, |
| {"sha256", "6d81e8f341edd17c127811f7347c7e23d18c2fc25c0bdc29ac56999cc9c25629"}, |
| {"size", uint64_t {45647664}}, |
| {"state", "inactive"}, |
| {"status", "ok"}, |
| {"type", "ext4"}, |
| }}, |
| }; |
| |
| expected = { |
| {"[name='B']", ""}, |
| {"[name='B']/is-healthy", "true"}, |
| {"[name='B']/installed", "2021-01-13T17:20:15-00:00"}, |
| {"[name='B']/name", "B"}, |
| {"[name='B']/is-booted-now", "true"}, |
| {"[name='B']/version", "v4-103-g34d2f48"}, |
| {"[name='B']/will-boot-next", "true"}, |
| }; |
| } |
| |
| auto raucServer = DBusRAUCServer(*dbusServerConnection, "rootfs.1", dbusRaucStatus); |
| auto sysrepo = std::make_shared<velia::system::Firmware>(srConn, *dbusClientConnectionSignals, *dbusClientConnectionMethods); |
| |
| REQUIRE(dataFromSysrepo(client, "/czechlight-system:firmware/firmware-slot", sysrepo::Datastore::Operational) == expected); |
| } |