From a5c612deb7685dae1fd5aececd81db28d159dd4e Mon Sep 17 00:00:00 2001 From: Jan Olszak Date: Tue, 22 Jul 2014 17:25:20 +0200 Subject: [PATCH] API for obtaining container's IDs [Bug/Feature] D-Bus API for getting the ID of the active container D-Bus API for getting the IDs of all containers [Cause] N/A [Solution] N/A [Verification] Build, install, run tests Change-Id: I03081e3dc5e275f9c0d5c6b5a6cacfef38c5adff --- server/containers-manager.cpp | 28 ++++++++ server/containers-manager.hpp | 2 + server/host-connection.cpp | 31 +++++++-- server/host-connection.hpp | 16 +++++ server/host-dbus-definitions.hpp | 8 +++ tests/unit_tests/server/ut-containers-manager.cpp | 80 ++++++++++++++++++++++- 6 files changed, 158 insertions(+), 7 deletions(-) diff --git a/server/containers-manager.cpp b/server/containers-manager.cpp index dc6e637..b2c4222 100644 --- a/server/containers-manager.cpp +++ b/server/containers-manager.cpp @@ -78,6 +78,12 @@ ContainersManager::ContainersManager(const std::string& managerConfigPath): mDet mHostConnection.setGetContainerDbusesCallback(bind( &ContainersManager::handleGetContainerDbuses, this, _1)); + mHostConnection.setGetContainerIdsCallback(bind(&ContainersManager::handleGetContainerIdsCall, + this, _1)); + + mHostConnection.setGetActiveContainerIdCallback(bind(&ContainersManager::handleGetActiveContainerIdCall, + this, _1)); + for (auto& containerConfig : mConfig.containerConfigs) { std::string containerConfigPath; @@ -416,5 +422,27 @@ void ContainersManager::handleDbusStateChanged(const std::string& containerId, mHostConnection.signalContainerDbusState(containerId, dbusAddress); } +void ContainersManager::handleGetContainerIdsCall(dbus::MethodResultBuilder::Pointer result) +{ + std::vector containerIds; + for(auto& container: mContainers){ + containerIds.push_back(g_variant_new_string(container.first.c_str())); + } + + GVariant* array = g_variant_new_array(G_VARIANT_TYPE("s"), + containerIds.data(), + containerIds.size()); + result->set(g_variant_new("(*)", array)); +} + +void ContainersManager::handleGetActiveContainerIdCall(dbus::MethodResultBuilder::Pointer result) +{ + LOGI("GetActiveContainerId call"); + if (mContainers[mConfig.foregroundId]->isRunning()){ + result->set(g_variant_new("(s)", mConfig.foregroundId.c_str())); + } else { + result->set(g_variant_new("(s)", "")); + } +} } // namespace security_containers diff --git a/server/containers-manager.hpp b/server/containers-manager.hpp index 8a5c823..b685028 100644 --- a/server/containers-manager.hpp +++ b/server/containers-manager.hpp @@ -105,6 +105,8 @@ private: void handleGetContainerDbuses(dbus::MethodResultBuilder::Pointer result); void handleDbusStateChanged(const std::string& containerId, const std::string& dbusAddress); + void handleGetContainerIdsCall(dbus::MethodResultBuilder::Pointer result); + void handleGetActiveContainerIdCall(dbus::MethodResultBuilder::Pointer result); }; diff --git a/server/host-connection.cpp b/server/host-connection.cpp index 88ce5a4..0d96039 100644 --- a/server/host-connection.cpp +++ b/server/host-connection.cpp @@ -65,12 +65,7 @@ HostConnection::HostConnection() mDbusConnection->registerObject(hostapi::OBJECT_PATH, hostapi::DEFINITION, std::bind(&HostConnection::onMessageCall, - this, - _1, - _2, - _3, - _4, - _5)); + this, _1, _2, _3, _4, _5)); LOGD("Connected"); } @@ -120,6 +115,16 @@ void HostConnection::setGetContainerDbusesCallback(const GetContainerDbusesCallb mGetContainerDbusesCallback = callback; } +void HostConnection::setGetContainerIdsCallback(const GetContainerIdsCallback& callback) +{ + mGetContainerIdsCallback = callback; +} + +void HostConnection::setGetActiveContainerIdCallback(const GetActiveContainerIdCallback& callback) +{ + mGetActiveContainerIdCallback = callback; +} + void HostConnection::onMessageCall(const std::string& objectPath, const std::string& interface, const std::string& methodName, @@ -165,6 +170,20 @@ void HostConnection::onMessageCall(const std::string& objectPath, } return; } + + if (methodName == hostapi::METHOD_GET_CONTAINER_ID_LIST){ + if (mGetContainerIdsCallback){ + mGetContainerIdsCallback(result); + } + return; + } + + if (methodName == hostapi::METHOD_GET_ACTIVE_CONTAINER_ID){ + if (mGetActiveContainerIdCallback){ + mGetActiveContainerIdCallback(result); + } + return; + } } void HostConnection::proxyCallAsync(const std::string& busName, diff --git a/server/host-connection.hpp b/server/host-connection.hpp index 3d9c493..962fbb9 100644 --- a/server/host-connection.hpp +++ b/server/host-connection.hpp @@ -54,6 +54,10 @@ public: typedef std::function GetContainerDbusesCallback; + typedef std::function GetContainerIdsCallback; + typedef std::function GetActiveContainerIdCallback; + /** * Register proxy call callback @@ -71,6 +75,16 @@ public: void signalContainerDbusState(const std::string& containerId, const std::string& dbusAddress); /** + * Register a callback called to get a list of domain ids + */ + void setGetContainerIdsCallback(const GetContainerIdsCallback& callback); + + /** + * Register a callback called to get the active container id + */ + void setGetActiveContainerIdCallback(const GetContainerIdsCallback& callback); + + /** * Make a proxy call */ void proxyCallAsync(const std::string& busName, @@ -88,6 +102,8 @@ private: bool mNameLost; ProxyCallCallback mProxyCallCallback; GetContainerDbusesCallback mGetContainerDbusesCallback; + GetContainerIdsCallback mGetContainerIdsCallback; + GetActiveContainerIdCallback mGetActiveContainerIdCallback; void onNameAcquired(); void onNameLost(); diff --git a/server/host-dbus-definitions.hpp b/server/host-dbus-definitions.hpp index 4594433..ef30e1a 100644 --- a/server/host-dbus-definitions.hpp +++ b/server/host-dbus-definitions.hpp @@ -38,6 +38,8 @@ const std::string INTERFACE = "org.tizen.containers.host const std::string METHOD_PROXY_CALL = "ProxyCall"; const std::string METHOD_GET_CONTAINER_DBUSES = "GetContainerDbuses"; +const std::string METHOD_GET_CONTAINER_ID_LIST = "GetContainerIds"; +const std::string METHOD_GET_ACTIVE_CONTAINER_ID = "GetActiveContainerId"; const std::string SIGNAL_CONTAINER_DBUS_STATE = "ContainerDbusState"; @@ -56,6 +58,12 @@ const std::string DEFINITION = " " " " " " + " " + " " + " " + " " + " " + " " " " " " " " diff --git a/tests/unit_tests/server/ut-containers-manager.cpp b/tests/unit_tests/server/ut-containers-manager.cpp index 43bc15a..d4708e3 100644 --- a/tests/unit_tests/server/ut-containers-manager.cpp +++ b/tests/unit_tests/server/ut-containers-manager.cpp @@ -223,7 +223,8 @@ public: return GVariantPtr(unpackedResult, g_variant_unref); } - Dbuses callMethodGetContainerDbuses() { + Dbuses callMethodGetContainerDbuses() + { assert(isHost()); Dbuses dbuses; GVariantPtr result = mClient->callMethod(hostapi::BUS_NAME, @@ -244,6 +245,47 @@ public: } return dbuses; } + + std::vector callMethodGetContainerIds() + { + assert(isHost()); + GVariantPtr result = mClient->callMethod(hostapi::BUS_NAME, + hostapi::OBJECT_PATH, + hostapi::INTERFACE, + hostapi::METHOD_GET_CONTAINER_ID_LIST, + NULL, + "(as)"); + + GVariant* array = NULL; + g_variant_get(result.get(), "(*)", &array); + + size_t arraySize = g_variant_n_children(array); + std::vector containerIds; + for (size_t i = 0; i < arraySize; ++i) { + const char* id = NULL; + g_variant_get_child(array, i, "&s", &id); + containerIds.push_back(id); + } + + g_variant_unref(array); + return containerIds; + } + + std::string callMethodGetActiveContainerId() + { + assert(isHost()); + GVariantPtr result = mClient->callMethod(hostapi::BUS_NAME, + hostapi::OBJECT_PATH, + hostapi::INTERFACE, + hostapi::METHOD_GET_ACTIVE_CONTAINER_ID, + NULL, + "(s)"); + + const char* containerId = NULL; + g_variant_get(result.get(), "(&s)", &containerId); + return containerId; + } + private: const int mId; DbusConnection::Pointer mClient; @@ -749,4 +791,40 @@ BOOST_AUTO_TEST_CASE(ContainerDbusesSignalsTest) } +BOOST_AUTO_TEST_CASE(GetContainerIdsTest) +{ + ContainersManager cm(TEST_DBUS_CONFIG_PATH); + + DbusAccessory dbus(DbusAccessory::HOST_ID); + + std::vector containerIds = {"ut-containers-manager-console1-dbus", + "ut-containers-manager-console2-dbus", + "ut-containers-manager-console3-dbus"}; + std::vector returnedIds = dbus.callMethodGetContainerIds(); + + BOOST_CHECK(std::is_permutation(returnedIds.begin(), + returnedIds.end(), + containerIds.begin())); +} + +BOOST_AUTO_TEST_CASE(GetActiveContainerIdTest) +{ + ContainersManager cm(TEST_DBUS_CONFIG_PATH); + cm.startAll(); + + DbusAccessory dbus(DbusAccessory::HOST_ID); + + std::vector containerIds = {"ut-containers-manager-console1-dbus", + "ut-containers-manager-console2-dbus", + "ut-containers-manager-console3-dbus"}; + + for (std::string& containerId: containerIds){ + cm.focus(containerId); + BOOST_CHECK(dbus.callMethodGetActiveContainerId() == containerId); + } + + cm.stopAll(); + BOOST_CHECK(dbus.callMethodGetActiveContainerId() == ""); +} + BOOST_AUTO_TEST_SUITE_END() -- 2.7.4