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

diff --git a/server/containers-manager.cpp b/server/containers-manager.cpp
index dc6e637..b2c4222 100644 (file)
--- 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<GVariant*> 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 (file)
--- 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 (file)
--- 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 (file)
--- a/server/host-connection.hpp
+++ b/server/host-connection.hpp
@@ -54,6 +54,10 @@ public:
 
     typedef std::function<void(dbus::MethodResultBuilder::Pointer result
                               )> GetContainerDbusesCallback;
+    typedef std::function<void(dbus::MethodResultBuilder::Pointer result)> GetContainerIdsCallback;
+    typedef std::function<void(dbus::MethodResultBuilder::Pointer result
+                              )> 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 (file)
--- 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 =
     "    <method name='" + METHOD_GET_CONTAINER_DBUSES + "'>"
     "      <arg type='a{ss}' name='dbuses' direction='out'/>"
     "    </method>"
+    "    <method name='" + METHOD_GET_CONTAINER_ID_LIST + "'>"
+    "      <arg type='as' name='result' direction='out'/>"
+    "    </method>"
+    "    <method name='" + METHOD_GET_ACTIVE_CONTAINER_ID + "'>"
+    "      <arg type='s' name='result' direction='out'/>"
+    "    </method>"
     "    <signal name='" + SIGNAL_CONTAINER_DBUS_STATE + "'>"
     "      <arg type='s' name='container'/>"
     "      <arg type='s' name='dbusAddress'/>"

diff --git a/tests/unit_tests/server/ut-containers-manager.cpp b/tests/unit_tests/server/ut-containers-manager.cpp
index 43bc15a..d4708e3 100644 (file)
--- 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<std::string> 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<std::string> 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<std::string> containerIds = {"ut-containers-manager-console1-dbus",
+                                             "ut-containers-manager-console2-dbus",
+                                             "ut-containers-manager-console3-dbus"};
+    std::vector<std::string> 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<std::string> 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()