From 9f7b75228aecd5bb8121b9b87f097febeaf4bc4b Mon Sep 17 00:00:00 2001 From: Philip Rauwolf Date: Wed, 2 Oct 2013 18:54:41 +0200 Subject: [PATCH] Removed limitation on Managed Services It now is possible to register more than one manager interface for a given D-Bus object path. Also did some random fixes and improvements wherever I saw them. Change-Id: I6616ef0bf9e46de99e1fb326f9038545af8af324 --- Makefile.am | 12 +- .../DBusInstanceAvailabilityStatusChangedEvent.h | 2 +- src/CommonAPI/DBus/DBusObjectManager.cpp | 85 +++- src/CommonAPI/DBus/DBusObjectManager.h | 24 +- src/CommonAPI/DBus/DBusObjectManagerStub.cpp | 44 +- src/CommonAPI/DBus/DBusObjectManagerStub.h | 34 +- src/CommonAPI/DBus/DBusProxyManager.cpp | 31 +- src/CommonAPI/DBus/DBusProxyManager.h | 11 +- src/CommonAPI/DBus/DBusServicePublisher.cpp | 23 +- src/CommonAPI/DBus/DBusStubAdapter.cpp | 4 +- src/CommonAPI/DBus/DBusStubAdapter.h | 17 +- src/CommonAPI/DBus/DBusStubAdapterHelper.h | 4 +- src/test/DBusCommunicationTest.cpp | 6 +- src/test/DBusManagedTest.cpp | 500 +++++++++++++++------ src/test/DBusObjectManagerStubTest.cpp | 220 +++++---- src/test/DBusServiceRegistryTest.cpp | 2 +- src/test/commonapi/tests/managed/BranchInterface.h | 2 +- .../tests/managed/BranchInterfaceDBusProxy.cpp | 2 +- .../tests/managed/BranchInterfaceDBusProxy.h | 2 +- .../managed/BranchInterfaceDBusStubAdapter.cpp | 5 +- .../tests/managed/BranchInterfaceDBusStubAdapter.h | 2 +- .../commonapi/tests/managed/BranchInterfaceProxy.h | 2 +- .../tests/managed/BranchInterfaceProxyBase.h | 2 +- .../commonapi/tests/managed/BranchInterfaceStub.h | 2 +- .../tests/managed/BranchInterfaceStubDefault.cpp | 2 +- .../tests/managed/BranchInterfaceStubDefault.h | 2 +- src/test/commonapi/tests/managed/LeafInterface.h | 2 +- .../tests/managed/LeafInterfaceDBusProxy.cpp | 2 +- .../tests/managed/LeafInterfaceDBusProxy.h | 2 +- .../tests/managed/LeafInterfaceDBusStubAdapter.cpp | 5 +- .../tests/managed/LeafInterfaceDBusStubAdapter.h | 2 +- src/test/commonapi/tests/managed/RootInterface.h | 2 +- .../tests/managed/RootInterfaceDBusProxy.cpp | 2 +- .../tests/managed/RootInterfaceDBusProxy.h | 2 +- .../tests/managed/RootInterfaceDBusStubAdapter.cpp | 31 +- .../tests/managed/RootInterfaceDBusStubAdapter.h | 2 +- .../commonapi/tests/managed/RootInterfaceProxy.h | 2 +- .../tests/managed/RootInterfaceProxyBase.h | 2 +- .../commonapi/tests/managed/RootInterfaceStub.h | 2 +- .../tests/managed/RootInterfaceStubDefault.cpp | 6 +- .../tests/managed/RootInterfaceStubDefault.h | 2 +- 41 files changed, 701 insertions(+), 407 deletions(-) diff --git a/Makefile.am b/Makefile.am index f93ac21..5d11387 100644 --- a/Makefile.am +++ b/Makefile.am @@ -187,6 +187,7 @@ DYNAMIC_LOADING_TEST_SET = \ check_PROGRAMS = \ DBusManagedTest \ + DBusObjectManagerStubTest \ DBusRuntimeTest \ ${DYNAMIC_LOADING_TEST_SET} \ DBusMainLoopIntegrationTest \ @@ -205,7 +206,6 @@ check_PROGRAMS = \ DBusMultipleConnectionTest \ DBusServicePublisherTest \ DBusClientIdTest \ - DBusObjectManagerStubTest \ DBusSelectiveBroadcastTest noinst_PROGRAMS = ${check_PROGRAMS} @@ -221,6 +221,11 @@ DBusManagedTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} ${GLIB_CFLAGS} DBusManagedTest_CXXFLAGS = ${GTEST_CXXFLAGS} ${GLIB_CFLAGS} DBusManagedTest_LDADD = ${LDADD_FOR_GTEST} ${GLIB_LIBS} +DBusObjectManagerStubTest_SOURCES = src/test/DBusObjectManagerStubTest.cpp +DBusObjectManagerStubTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} +DBusObjectManagerStubTest_CXXFLAGS = ${GTEST_CXXFLAGS} +DBusObjectManagerStubTest_LDADD = ${LDADD_FOR_GTEST} + DBusMainLoopIntegrationTest_SOURCES = \ src/test/DBusMainLoopIntegrationTest.cpp \ ${TestInterfaceDBusSources} @@ -362,11 +367,6 @@ DBusClientIdTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} DBusClientIdTest_CXXFLAGS = ${GTEST_CXXFLAGS} DBusClientIdTest_LDADD = ${LDADD_FOR_GTEST} -DBusObjectManagerStubTest_SOURCES = src/test/DBusObjectManagerStubTest.cpp -DBusObjectManagerStubTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} -DBusObjectManagerStubTest_CXXFLAGS = ${GTEST_CXXFLAGS} -DBusObjectManagerStubTest_LDADD = ${LDADD_FOR_GTEST} - DBusSelectiveBroadcastTest_SOURCES = \ ${TestInterfaceDBusSources} \ src/test/DBusSelectiveBroadcastTest.cpp diff --git a/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h b/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h index d9bb975..456ed8d 100644 --- a/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h +++ b/src/CommonAPI/DBus/DBusInstanceAvailabilityStatusChangedEvent.h @@ -32,7 +32,7 @@ class DBusInstanceAvailabilityStatusChangedEvent: public ProxyManager::InstanceAvailabilityStatusChangedEvent, public DBusProxyConnection::DBusSignalHandler { public: - DBusInstanceAvailabilityStatusChangedEvent(DBusProxy& dbusProxy, const char* interfaceName) : + DBusInstanceAvailabilityStatusChangedEvent(DBusProxy& dbusProxy, const std::string& interfaceName) : dbusProxy_(dbusProxy), observedInterfaceName_(interfaceName) { } diff --git a/src/CommonAPI/DBus/DBusObjectManager.cpp b/src/CommonAPI/DBus/DBusObjectManager.cpp index 69a4f2a..3525585 100644 --- a/src/CommonAPI/DBus/DBusObjectManager.cpp +++ b/src/CommonAPI/DBus/DBusObjectManager.cpp @@ -24,7 +24,7 @@ namespace DBus { DBusObjectManager::DBusObjectManager(const std::shared_ptr& dbusConnection): dbusConnection_(dbusConnection), - rootDBusObjectManagerStub_("/", dbusConnection) { + rootDBusObjectManagerStub_(new DBusObjectManagerStub("/", dbusConnection)) { if (!dbusConnection->isObjectPathMessageHandlerSet()) { dbusConnection->setObjectPathMessageHandler( @@ -34,7 +34,7 @@ DBusObjectManager::DBusObjectManager(const std::shared_ptr& dbusRegisteredObjectsTable_.insert({ DBusInterfaceHandlerPath("/", DBusObjectManagerStub::getInterfaceName()), - &rootDBusObjectManagerStub_ }); + rootDBusObjectManagerStub_ }); } DBusObjectManager::~DBusObjectManager() { @@ -45,7 +45,7 @@ DBusObjectManager::~DBusObjectManager() { } } -bool DBusObjectManager::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) { +bool DBusObjectManager::registerDBusStubAdapter(std::shared_ptr dbusStubAdapter) { const auto& dbusStubAdapterObjectPath = dbusStubAdapter->getObjectPath(); const auto& dbusStubAdapterInterfaceName = dbusStubAdapter->getInterfaceName(); DBusInterfaceHandlerPath dbusStubAdapterHandlerPath(dbusStubAdapterObjectPath, dbusStubAdapterInterfaceName); @@ -54,8 +54,21 @@ bool DBusObjectManager::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter objectPathLock_.lock(); isRegistrationSuccessful = addDBusInterfaceHandler(dbusStubAdapterHandlerPath, dbusStubAdapter); - if (isRegistrationSuccessful && dbusStubAdapter->hasDBusObjectManagerStub()) { - auto dbusObjectManagerStub = dbusStubAdapter->getDBusObjectManagerStub(); + if (isRegistrationSuccessful && dbusStubAdapter->isManagingInterface()) { + auto managerStubIterator = managerStubs_.find(dbusStubAdapterObjectPath); + const bool managerStubExists = managerStubIterator != managerStubs_.end(); + + if (!managerStubExists) { + const std::shared_ptr newManagerStub = std::make_shared(dbusStubAdapterObjectPath, dbusStubAdapter->getDBusConnection()); + auto insertResult = managerStubs_.insert( {dbusStubAdapterObjectPath, {newManagerStub, 1} }); + assert(insertResult.second); + managerStubIterator = insertResult.first; + } else { + uint32_t& countReferencesToManagerStub = std::get<1>(managerStubIterator->second); + ++countReferencesToManagerStub; + } + + std::shared_ptr dbusObjectManagerStub = std::get<0>(managerStubIterator->second); assert(dbusObjectManagerStub); isRegistrationSuccessful = addDBusInterfaceHandler( @@ -78,7 +91,8 @@ bool DBusObjectManager::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter return isRegistrationSuccessful; } -bool DBusObjectManager::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) { + +bool DBusObjectManager::unregisterDBusStubAdapter(std::shared_ptr dbusStubAdapter) { const auto& dbusStubAdapterObjectPath = dbusStubAdapter->getObjectPath(); const auto& dbusStubAdapterInterfaceName = dbusStubAdapter->getInterfaceName(); DBusInterfaceHandlerPath dbusStubAdapterHandlerPath(dbusStubAdapterObjectPath, dbusStubAdapterInterfaceName); @@ -87,16 +101,22 @@ bool DBusObjectManager::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapt objectPathLock_.lock(); isDeregistrationSuccessful = removeDBusInterfaceHandler(dbusStubAdapterHandlerPath, dbusStubAdapter); - if (isDeregistrationSuccessful && dbusStubAdapter->hasDBusObjectManagerStub()) { - auto dbusObjectManagerStub = dbusStubAdapter->getDBusObjectManagerStub(); + if (isDeregistrationSuccessful && dbusStubAdapter->isManagingInterface()) { + auto managerStubIterator = managerStubs_.find(dbusStubAdapterObjectPath); + assert(managerStubIterator != managerStubs_.end()); + + std::shared_ptr dbusObjectManagerStub = std::get<0>(managerStubIterator->second); assert(dbusObjectManagerStub); - isDeregistrationSuccessful = removeDBusInterfaceHandler( - { dbusStubAdapterObjectPath, dbusObjectManagerStub->getInterfaceName() }, dbusObjectManagerStub); + uint32_t& countReferencesToManagerStub = std::get<1>(managerStubIterator->second); + assert(countReferencesToManagerStub > 0); + --countReferencesToManagerStub; - if (!isDeregistrationSuccessful) { - const bool isDBusStubAdapterAdded = addDBusInterfaceHandler(dbusStubAdapterHandlerPath, dbusStubAdapter); - assert(isDBusStubAdapterAdded); + if (countReferencesToManagerStub == 0) { + isDeregistrationSuccessful = removeDBusInterfaceHandler( + { dbusStubAdapterObjectPath, dbusObjectManagerStub->getInterfaceName() }, dbusObjectManagerStub); + managerStubs_.erase(managerStubIterator); + assert(isDeregistrationSuccessful); } } @@ -112,6 +132,33 @@ bool DBusObjectManager::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapt return isDeregistrationSuccessful; } + +bool DBusObjectManager::exportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr dbusStubAdapter) { + auto foundManagerStubIterator = managerStubs_.find(parentObjectPath); + + assert(foundManagerStubIterator != managerStubs_.end()); + + if (std::get<0>(foundManagerStubIterator->second)->exportManagedDBusStubAdapter(dbusStubAdapter)) { + //XXX Other handling necessary? + return true; + } + return false; +} + + +bool DBusObjectManager::unexportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr dbusStubAdapter) { + auto foundManagerStubIterator = managerStubs_.find(parentObjectPath); + + assert(foundManagerStubIterator != managerStubs_.end()); + + if (std::get<0>(foundManagerStubIterator->second)->unexportManagedDBusStubAdapter(dbusStubAdapter)) { + //XXX Other handling necessary? + return true; + } + return false; +} + + bool DBusObjectManager::handleMessage(const DBusMessage& dbusMessage) { const char* objectPath = dbusMessage.getObjectPath(); const char* interfaceName = dbusMessage.getInterfaceName(); @@ -127,7 +174,7 @@ bool DBusObjectManager::handleMessage(const DBusMessage& dbusMessage) { bool dbusMessageHandled = false; if (foundDBusInterfaceHandler) { - DBusInterfaceHandler* dbusStubAdapterBase = handlerIterator->second; + std::shared_ptr dbusStubAdapterBase = handlerIterator->second; dbusMessageHandled = dbusStubAdapterBase->onInterfaceDBusMessage(dbusMessage); } else if (dbusMessage.hasInterfaceName("org.freedesktop.DBus.Introspectable")) { dbusMessageHandled = onIntrospectableInterfaceDBusMessage(dbusMessage); @@ -138,11 +185,15 @@ bool DBusObjectManager::handleMessage(const DBusMessage& dbusMessage) { } bool DBusObjectManager::addDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath, - DBusInterfaceHandler* dbusInterfaceHandler) { + std::shared_ptr dbusInterfaceHandler) { const auto& dbusRegisteredObjectsTableIter = dbusRegisteredObjectsTable_.find(dbusInterfaceHandlerPath); const bool isDBusInterfaceHandlerAlreadyAdded = (dbusRegisteredObjectsTableIter != dbusRegisteredObjectsTable_.end()); if (isDBusInterfaceHandlerAlreadyAdded) { + //If another ObjectManager is to be registered, you can go on and just use the first one. + if (dbusInterfaceHandlerPath.second == "org.freedesktop.DBus.ObjectManager") { + return true; + } return false; } @@ -153,7 +204,7 @@ bool DBusObjectManager::addDBusInterfaceHandler(const DBusInterfaceHandlerPath& } bool DBusObjectManager::removeDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath, - DBusInterfaceHandler* dbusInterfaceHandler) { + std::shared_ptr dbusInterfaceHandler) { const auto& dbusRegisteredObjectsTableIter = dbusRegisteredObjectsTable_.find(dbusInterfaceHandlerPath); const bool isDBusInterfaceHandlerAdded = (dbusRegisteredObjectsTableIter != dbusRegisteredObjectsTable_.end()); @@ -191,7 +242,7 @@ bool DBusObjectManager::onIntrospectableInterfaceDBusMessage(const DBusMessage& const DBusInterfaceHandlerPath& handlerPath = registeredObjectsIterator.first; const std::string& dbusObjectPath = handlerPath.first; const std::string& dbusInterfaceName = handlerPath.second; - DBusInterfaceHandler* dbusStubAdapterBase = registeredObjectsIterator.second; + std::shared_ptr dbusStubAdapterBase = registeredObjectsIterator.second; std::vector elems = CommonAPI::split(dbusObjectPath, '/'); if (dbusMessage.hasObjectPath(dbusObjectPath)) { diff --git a/src/CommonAPI/DBus/DBusObjectManager.h b/src/CommonAPI/DBus/DBusObjectManager.h index 130ac0c..c81fea6 100644 --- a/src/CommonAPI/DBus/DBusObjectManager.h +++ b/src/CommonAPI/DBus/DBusObjectManager.h @@ -28,36 +28,44 @@ class DBusObjectManager { DBusObjectManager(const std::shared_ptr&); ~DBusObjectManager(); - bool registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter); - bool unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter); + bool registerDBusStubAdapter(std::shared_ptr dbusStubAdapter); + bool unregisterDBusStubAdapter(std::shared_ptr dbusStubAdapter); + + //Zusammenfassbar mit "registerDBusStubAdapter"? + bool exportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr dbusStubAdapter); + bool unexportManagedDBusStubAdapter(const std::string& parentObjectPath, std::shared_ptr dbusStubAdapter); bool handleMessage(const DBusMessage&); - inline DBusObjectManagerStub& getRootDBusObjectManagerStub(); + inline std::shared_ptr getRootDBusObjectManagerStub(); private: // objectPath, interfaceName typedef std::pair DBusInterfaceHandlerPath; bool addDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath, - DBusInterfaceHandler* dbusInterfaceHandler); + std::shared_ptr dbusInterfaceHandler); bool removeDBusInterfaceHandler(const DBusInterfaceHandlerPath& dbusInterfaceHandlerPath, - DBusInterfaceHandler* dbusInterfaceHandler); + std::shared_ptr dbusInterfaceHandler); bool onIntrospectableInterfaceDBusMessage(const DBusMessage& callMessage); - typedef std::unordered_map DBusRegisteredObjectsTable; + typedef std::unordered_map> DBusRegisteredObjectsTable; DBusRegisteredObjectsTable dbusRegisteredObjectsTable_; - DBusObjectManagerStub rootDBusObjectManagerStub_; + std::shared_ptr rootDBusObjectManagerStub_; + + typedef std::pair, uint32_t> ReferenceCountedDBusObjectManagerStub; + typedef std::unordered_map RegisteredObjectManagersTable; + RegisteredObjectManagersTable managerStubs_; std::weak_ptr dbusConnection_; std::recursive_mutex objectPathLock_; }; -DBusObjectManagerStub& DBusObjectManager::getRootDBusObjectManagerStub() { +std::shared_ptr DBusObjectManager::getRootDBusObjectManagerStub() { return rootDBusObjectManagerStub_; } diff --git a/src/CommonAPI/DBus/DBusObjectManagerStub.cpp b/src/CommonAPI/DBus/DBusObjectManagerStub.cpp index c574998..5d0f721 100644 --- a/src/CommonAPI/DBus/DBusObjectManagerStub.cpp +++ b/src/CommonAPI/DBus/DBusObjectManagerStub.cpp @@ -17,7 +17,7 @@ namespace DBus { DBusObjectManagerStub::DBusObjectManagerStub(const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection) : - dbusConnectionWeakPtr_(dbusConnection), + dbusConnection_(dbusConnection), dbusObjectPath_(dbusObjectPath) { assert(!dbusObjectPath.empty()); assert(dbusObjectPath[0] == '/'); @@ -39,22 +39,22 @@ DBusObjectManagerStub::~DBusObjectManagerStub() { } } -bool DBusObjectManagerStub::exportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) { - assert(dbusStubAdapter); +bool DBusObjectManagerStub::exportManagedDBusStubAdapter(std::shared_ptr managedDBusStubAdapter) { + assert(managedDBusStubAdapter); std::lock_guard dbusObjectManagerStubLock(dbusObjectManagerStubLock_); - const bool isRegistrationSuccessful = registerDBusStubAdapter(dbusStubAdapter); + const bool isRegistrationSuccessful = registerDBusStubAdapter(managedDBusStubAdapter); if (!isRegistrationSuccessful) { return false; } - auto dbusConnection = dbusConnectionWeakPtr_.lock(); + auto dbusConnection = dbusConnection_.lock(); if (dbusConnection && dbusConnection->isConnected()) { - const bool isDBusSignalEmitted = emitInterfacesAddedSignal(dbusStubAdapter, dbusConnection); + const bool isDBusSignalEmitted = emitInterfacesAddedSignal(managedDBusStubAdapter, dbusConnection); if (!isDBusSignalEmitted) { - unregisterDBusStubAdapter(dbusStubAdapter); + unregisterDBusStubAdapter(managedDBusStubAdapter); return false; } } @@ -62,22 +62,22 @@ bool DBusObjectManagerStub::exportDBusStubAdapter(DBusStubAdapter* dbusStubAdapt return true; } -bool DBusObjectManagerStub::unexportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) { - assert(dbusStubAdapter); +bool DBusObjectManagerStub::unexportManagedDBusStubAdapter(std::shared_ptr managedDBusStubAdapter) { + assert(managedDBusStubAdapter); std::lock_guard dbusObjectManagerStubLock(dbusObjectManagerStubLock_); - const bool isRegistrationSuccessful = unregisterDBusStubAdapter(dbusStubAdapter); + const bool isRegistrationSuccessful = unregisterDBusStubAdapter(managedDBusStubAdapter); if (!isRegistrationSuccessful) { return false; } - auto dbusConnection = dbusConnectionWeakPtr_.lock(); + auto dbusConnection = dbusConnection_.lock(); if (dbusConnection && dbusConnection->isConnected()) { - const bool isDBusSignalEmitted = emitInterfacesRemovedSignal(dbusStubAdapter, dbusConnection); + const bool isDBusSignalEmitted = emitInterfacesRemovedSignal(managedDBusStubAdapter, dbusConnection); if (!isDBusSignalEmitted) { - registerDBusStubAdapter(dbusStubAdapter); + registerDBusStubAdapter(managedDBusStubAdapter); return false; } } @@ -85,7 +85,7 @@ bool DBusObjectManagerStub::unexportDBusStubAdapter(DBusStubAdapter* dbusStubAda return true; } -bool DBusObjectManagerStub::isDBusStubAdapterExported(DBusStubAdapter* dbusStubAdapter) { +bool DBusObjectManagerStub::isDBusStubAdapterExported(std::shared_ptr dbusStubAdapter) { assert(dbusStubAdapter); const auto& dbusObjectPath = dbusStubAdapter->getObjectPath(); @@ -112,7 +112,7 @@ bool DBusObjectManagerStub::isDBusStubAdapterExported(DBusStubAdapter* dbusStubA return isRegisteredDBusInterfaceName; } -bool DBusObjectManagerStub::registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) { +bool DBusObjectManagerStub::registerDBusStubAdapter(std::shared_ptr dbusStubAdapter) { const auto& dbusObjectPath = dbusStubAdapter->getObjectPath(); const auto& dbusInterfaceName = dbusStubAdapter->getInterfaceName(); const auto& registeredDBusObjectPathIterator = registeredDBusObjectPathsMap_.find(dbusObjectPath); @@ -138,7 +138,7 @@ bool DBusObjectManagerStub::registerDBusStubAdapter(DBusStubAdapter* dbusStubAda return isRegisterationSuccessful; } -bool DBusObjectManagerStub::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter) { +bool DBusObjectManagerStub::unregisterDBusStubAdapter(std::shared_ptr dbusStubAdapter) { const auto& dbusObjectPath = dbusStubAdapter->getObjectPath(); const auto& dbusInterfaceName = dbusStubAdapter->getInterfaceName(); const auto& registeredDBusObjectPathIterator = registeredDBusObjectPathsMap_.find(dbusObjectPath); @@ -169,7 +169,7 @@ bool DBusObjectManagerStub::unregisterDBusStubAdapter(DBusStubAdapter* dbusStubA } -bool DBusObjectManagerStub::emitInterfacesAddedSignal(DBusStubAdapter* dbusStubAdapter, +bool DBusObjectManagerStub::emitInterfacesAddedSignal(std::shared_ptr dbusStubAdapter, const std::shared_ptr& dbusConnection) const { assert(dbusConnection); assert(dbusConnection->isConnected()); @@ -182,7 +182,7 @@ bool DBusObjectManagerStub::emitInterfacesAddedSignal(DBusStubAdapter* dbusStubA { dbusStubInterfaceName, DBusPropertiesChangedDict() } }); - if (dbusStubAdapter->hasDBusObjectManagerStub()) { + if (dbusStubAdapter->isManagingInterface()) { dbusInterfacesAndPropertiesDict.insert({ getInterfaceName(), DBusPropertiesChangedDict() }); } @@ -194,7 +194,7 @@ bool DBusObjectManagerStub::emitInterfacesAddedSignal(DBusStubAdapter* dbusStubA return dbusSignalEmitted; } -bool DBusObjectManagerStub::emitInterfacesRemovedSignal(DBusStubAdapter* dbusStubAdapter, +bool DBusObjectManagerStub::emitInterfacesRemovedSignal(std::shared_ptr dbusStubAdapter, const std::shared_ptr& dbusConnection) const { assert(dbusConnection); assert(dbusConnection->isConnected()); @@ -205,7 +205,7 @@ bool DBusObjectManagerStub::emitInterfacesRemovedSignal(DBusStubAdapter* dbusStu DBusOutputStream dbusOutputStream(dbusSignal); std::vector removedInterfaces({ { dbusStubInterfaceName } }); - if (dbusStubAdapter->hasDBusObjectManagerStub()) { + if (dbusStubAdapter->isManagingInterface()) { removedInterfaces.push_back(getInterfaceName()); } @@ -232,7 +232,7 @@ const char* DBusObjectManagerStub::getMethodsDBusIntrospectionXmlData() const { } bool DBusObjectManagerStub::onInterfaceDBusMessage(const DBusMessage& dbusMessage) { - auto dbusConnection = dbusConnectionWeakPtr_.lock(); + auto dbusConnection = dbusConnection_.lock(); if (!dbusConnection || !dbusConnection->isConnected()) { return false; @@ -261,7 +261,7 @@ bool DBusObjectManagerStub::onInterfaceDBusMessage(const DBusMessage& dbusMessag dbusInterfacesAndPropertiesDict.insert({ registeredDBusInterfaceName, DBusPropertiesChangedDict() }); - if (registeredDBusStubAdapter->hasDBusObjectManagerStub()) { + if (registeredDBusStubAdapter->isManagingInterface()) { dbusInterfacesAndPropertiesDict.insert({ getInterfaceName(), DBusPropertiesChangedDict() }); } } diff --git a/src/CommonAPI/DBus/DBusObjectManagerStub.h b/src/CommonAPI/DBus/DBusObjectManagerStub.h index 42db8e3..7335602 100644 --- a/src/CommonAPI/DBus/DBusObjectManagerStub.h +++ b/src/CommonAPI/DBus/DBusObjectManagerStub.h @@ -7,20 +7,6 @@ #ifndef COMMONAPI_DBUS_DBUS_FREEDESKTOP_OBJECT_MANAGER_STUB_H_ #define COMMONAPI_DBUS_DBUS_FREEDESKTOP_OBJECT_MANAGER_STUB_H_ -// TODO rename DBusObjectManager to DBusStubManager - -// TODO proxy/client logic simply instantiates DBusObjectManagerProxy -// with the object path of the currently instantiated proxy. That -// way asking about available instances is a matter of calling -// getManagedObjects(). Maybe we'll also have to cache within the -// proxy like the service registry is doing. - -// TODO Service Discovery -// - first detect all objects of a service via the Introspectible interface (like d-feet does). -// - Introspectible is less efficient than a global ObjectManager but a global ObjectManager -// conflicts with local ones, so we can't intentionally have one. The tradeoff is efficiency for correctness -// - Register for all InterfaceAdded and InterfaceRemoved signals on the bus. -// - Handle double InterfaceAdded and InterfaceRemoved signals properly (ignore them!). #include "DBusInterfaceHandler.h" @@ -57,7 +43,7 @@ class DBusStubAdapter; */ class DBusObjectManagerStub: public DBusInterfaceHandler { public: - // XXX serialization trick: use bool instead of variant since we never serialize it + // serialization trick: use bool instead of variant since we never serialize it typedef std::unordered_map DBusPropertiesChangedDict; typedef std::unordered_map DBusInterfacesAndPropertiesDict; typedef std::unordered_map DBusObjectPathAndInterfacesDict; @@ -88,7 +74,7 @@ class DBusObjectManagerStub: public DBusInterfaceHandler { * @see CommonAPI::ServicePublisher * @see DBusObjectManager */ - bool exportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter); + bool exportManagedDBusStubAdapter(std::shared_ptr dbusStubAdapter); /** * Unexport DBusStubAdapter instance from this DBusObjectManagerStub instance. @@ -104,9 +90,9 @@ class DBusObjectManagerStub: public DBusInterfaceHandler { * * @see exportDBusStubAdapter() */ - bool unexportDBusStubAdapter(DBusStubAdapter* dbusStubAdapter); + bool unexportManagedDBusStubAdapter(std::shared_ptr dbusStubAdapter); - bool isDBusStubAdapterExported(DBusStubAdapter* dbusStubAdapter); + bool isDBusStubAdapterExported(std::shared_ptr dbusStubAdapter); inline const std::string& getDBusObjectPath() const; inline static const char* getInterfaceName(); @@ -115,19 +101,19 @@ class DBusObjectManagerStub: public DBusInterfaceHandler { virtual bool onInterfaceDBusMessage(const DBusMessage& dbusMessage); private: - bool registerDBusStubAdapter(DBusStubAdapter* dbusStubAdapter); - bool unregisterDBusStubAdapter(DBusStubAdapter* dbusStubAdapter); + bool registerDBusStubAdapter(std::shared_ptr dbusStubAdapter); + bool unregisterDBusStubAdapter(std::shared_ptr dbusStubAdapter); - bool emitInterfacesAddedSignal(DBusStubAdapter* dbusStubAdapter, + bool emitInterfacesAddedSignal(std::shared_ptr dbusStubAdapter, const std::shared_ptr& dbusConnection) const; - bool emitInterfacesRemovedSignal(DBusStubAdapter* dbusStubAdapter, + bool emitInterfacesRemovedSignal(std::shared_ptr dbusStubAdapter, const std::shared_ptr& dbusConnection) const; std::string dbusObjectPath_; - std::weak_ptr dbusConnectionWeakPtr_; + std::weak_ptr dbusConnection_; - typedef std::unordered_map DBusInterfacesMap; + typedef std::unordered_map> DBusInterfacesMap; typedef std::unordered_map DBusObjectPathsMap; DBusObjectPathsMap registeredDBusObjectPathsMap_; diff --git a/src/CommonAPI/DBus/DBusProxyManager.cpp b/src/CommonAPI/DBus/DBusProxyManager.cpp index 7765532..b8ba87e 100644 --- a/src/CommonAPI/DBus/DBusProxyManager.cpp +++ b/src/CommonAPI/DBus/DBusProxyManager.cpp @@ -13,12 +13,12 @@ namespace DBus { DBusProxyManager::DBusProxyManager(DBusProxy& dbusProxy, - const char* interfaceName, - const std::shared_ptr& factory) : + const std::string& interfaceId, + const std::shared_ptr factory) : dbusProxy_(dbusProxy), - dbusInstanceAvailabilityStatusEvent_(dbusProxy, interfaceName), + dbusInstanceAvailabilityStatusEvent_(dbusProxy, interfaceId), factory_(factory), - interfaceName_(interfaceName) , + interfaceId_(interfaceId), registry_(dbusProxy.getDBusConnection()->getDBusServiceRegistry()) { } @@ -41,12 +41,10 @@ void DBusProxyManager::getAvailableInstances(CommonAPI::CallStatus& callStatus, dbusProxy_, DBusObjectManagerStub::getInterfaceName(), "GetManagedObjects", - "a{oa{sa{sv}}}", + "", callStatus, dbusObjectPathAndInterfacesDict); - - if (callStatus == CallStatus::SUCCESS) { translateCommonApiAddresses(dbusObjectPathAndInterfacesDict, availableInstances); } @@ -75,7 +73,7 @@ void DBusProxyManager::getInstanceAvailabilityStatus(const std::string& instance AvailabilityStatus& availabilityStatus) { std::stringstream ss; - ss << "local:" << interfaceName_ << ":" << instanceAddress; + ss << "local:" << interfaceId_ << ":" << instanceAddress; std::string interfaceName; std::string connectionName; @@ -101,7 +99,7 @@ SubscriptionStatus DBusProxyManager::instanceAliveAsyncCallback(const Availabili std::future DBusProxyManager::getInstanceAvailabilityStatusAsync(const std::string& instanceAddress, GetInstanceAvailabilityStatusCallback callback) { std::stringstream ss; - ss << "local:" << interfaceName_ << ":" << instanceAddress; + ss << "local:" << interfaceId_ << ":" << instanceAddress; std::shared_ptr > promise = std::make_shared>(); @@ -122,28 +120,31 @@ DBusProxyManager::InstanceAvailabilityStatusChangedEvent& DBusProxyManager::getI } void DBusProxyManager::translateCommonApiAddresses(const DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict, - std::vector& commonApiAddresses) { + std::vector& instanceIds) { for (const auto& dbusObjectPathIter : dbusObjectPathAndInterfacesDict) { const std::string& dbusObjectPath = dbusObjectPathIter.first; const auto& dbusInterfacesDict = dbusObjectPathIter.second; for (const auto& dbusInterfaceIter : dbusInterfacesDict) { const std::string dbusInterfaceName = dbusInterfaceIter.first; - std::string commonApiAddress; + std::string instanceId; DBusAddressTranslator::getInstance().searchForCommonAddress( dbusInterfaceName, dbusProxy_.getDBusBusName(), dbusObjectPath, - commonApiAddress); + instanceId); + + auto pos = instanceId.find_last_of(':'); + instanceId = instanceId.substr(pos + 1, instanceId.size()); - commonApiAddresses.push_back(commonApiAddress); + instanceIds.push_back(instanceId); } } } -std::shared_ptr DBusProxyManager::createProxy(const std::string& instanceName) { - return factory_->createProxy(interfaceName_, instanceName, interfaceName_, "local"); +std::shared_ptr DBusProxyManager::createProxy(const std::string& instanceId) { + return factory_->createProxy(interfaceId_.c_str(), instanceId, interfaceId_, "local"); } diff --git a/src/CommonAPI/DBus/DBusProxyManager.h b/src/CommonAPI/DBus/DBusProxyManager.h index bbef57f..73f612f 100644 --- a/src/CommonAPI/DBus/DBusProxyManager.h +++ b/src/CommonAPI/DBus/DBusProxyManager.h @@ -30,7 +30,9 @@ namespace DBus { class DBusProxyManager: public ProxyManager { public: - DBusProxyManager(DBusProxy& dbusProxy, const char* interfaceName, const std::shared_ptr& factory); + DBusProxyManager(DBusProxy& dbusProxy, + const std::string& interfaceName, + const std::shared_ptr factory); virtual void getAvailableInstances(CommonAPI::CallStatus&, std::vector& availableInstances); virtual std::future getAvailableInstancesAsync(GetAvailableInstancesCallback callback); @@ -44,7 +46,7 @@ class DBusProxyManager: public ProxyManager { virtual InstanceAvailabilityStatusChangedEvent& getInstanceAvailabilityStatusChangedEvent(); protected: - virtual std::shared_ptr createProxy(const std::string& instanceName); + virtual std::shared_ptr createProxy(const std::string& instanceId); private: void instancesAsyncCallback(const CommonAPI::CallStatus& status, @@ -56,13 +58,14 @@ class DBusProxyManager: public ProxyManager { std::shared_ptr >& callStatus); void translateCommonApiAddresses(const DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict, - std::vector& commonApiAddresses); + std::vector& instanceIds); DBusProxy& dbusProxy_; DBusInstanceAvailabilityStatusChangedEvent dbusInstanceAvailabilityStatusEvent_; const std::shared_ptr factory_; const std::shared_ptr registry_; - const char* interfaceName_; + + const std::string interfaceId_; }; } // namespace DBus diff --git a/src/CommonAPI/DBus/DBusServicePublisher.cpp b/src/CommonAPI/DBus/DBusServicePublisher.cpp index 77c9647..6f6a4c7 100644 --- a/src/CommonAPI/DBus/DBusServicePublisher.cpp +++ b/src/CommonAPI/DBus/DBusServicePublisher.cpp @@ -26,14 +26,14 @@ std::shared_ptr DBusServicePublisher::getInstance() { bool DBusServicePublisher::registerService(const std::shared_ptr& dbusStubAdapter) { auto serviceAddress = dbusStubAdapter->getAddress(); const auto& dbusConnection = dbusStubAdapter->getDBusConnection(); - DBusObjectManagerStub& rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub(); - const bool isManagedRegistrationSuccessfull = registerManagedService(dbusStubAdapter); + std::shared_ptr rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub(); + const bool isRegistrationAtManagerSuccessfull = registerManagedService(dbusStubAdapter); - if (!isManagedRegistrationSuccessfull) { + if (!isRegistrationAtManagerSuccessfull) { return false; } - const bool isServiceExportSuccessful = rootDBusObjectManagerStub.exportDBusStubAdapter(dbusStubAdapter.get()); + const bool isServiceExportSuccessful = rootDBusObjectManagerStub->exportManagedDBusStubAdapter(dbusStubAdapter); if (!isServiceExportSuccessful) { const bool isManagedDeregistrationSuccessfull = unregisterManagedService(serviceAddress); assert(isManagedDeregistrationSuccessfull); @@ -70,6 +70,7 @@ bool DBusServicePublisher::registerService(const std::shared_ptr& stub return isRegistrationSuccessful; } + bool DBusServicePublisher::unregisterService(const std::string& serviceAddress) { auto registeredServiceIterator = registeredServices_.find(serviceAddress); const bool isServiceAddressRegistered = (registeredServiceIterator != registeredServices_.end()); @@ -80,11 +81,11 @@ bool DBusServicePublisher::unregisterService(const std::string& serviceAddress) const auto& registeredDBusStubAdapter = registeredServiceIterator->second; const auto& dbusConnection = registeredDBusStubAdapter->getDBusConnection(); - auto& rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub(); - const bool isRootService = rootDBusObjectManagerStub.isDBusStubAdapterExported(registeredDBusStubAdapter.get()); + std::shared_ptr rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub(); + const bool isRootService = rootDBusObjectManagerStub->isDBusStubAdapterExported(registeredDBusStubAdapter); registeredDBusStubAdapter->deactivateManagedInstances(); if (isRootService) { - const bool isUnexportSuccessfull = rootDBusObjectManagerStub.unexportDBusStubAdapter(registeredDBusStubAdapter.get()); + const bool isUnexportSuccessfull = rootDBusObjectManagerStub->unexportManagedDBusStubAdapter(registeredDBusStubAdapter); assert(isUnexportSuccessfull); unregisterManagedService(registeredServiceIterator); @@ -93,6 +94,7 @@ bool DBusServicePublisher::unregisterService(const std::string& serviceAddress) return isRootService; } + bool DBusServicePublisher::registerManagedService(const std::shared_ptr& managedDBusStubAdapter) { auto serviceAddress = managedDBusStubAdapter->getAddress(); const auto& insertResult = registeredServices_.insert( {serviceAddress, managedDBusStubAdapter} ); @@ -105,7 +107,7 @@ bool DBusServicePublisher::registerManagedService(const std::shared_ptrgetDBusConnection(); const auto dbusObjectManager = dbusConnection->getDBusObjectManager(); - const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(managedDBusStubAdapter.get()); + const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(managedDBusStubAdapter); if (!isDBusObjectRegistrationSuccessful) { registeredServices_.erase(insertIter); return false; @@ -114,7 +116,7 @@ bool DBusServicePublisher::registerManagedService(const std::shared_ptrgetDBusName(); const bool isServiceNameAcquired = dbusConnection->requestServiceNameAndBlock(dbusServiceName); if (!isServiceNameAcquired) { - const bool isDBusObjectDeregistrationSuccessful = dbusObjectManager->unregisterDBusStubAdapter(managedDBusStubAdapter.get()); + const bool isDBusObjectDeregistrationSuccessful = dbusObjectManager->unregisterDBusStubAdapter(managedDBusStubAdapter); assert(isDBusObjectDeregistrationSuccessful); registeredServices_.erase(insertIter); @@ -123,6 +125,7 @@ bool DBusServicePublisher::registerManagedService(const std::shared_ptrgetDBusObjectManager(); const auto& dbusServiceName = registeredDbusStubAdapter->getDBusName(); - const bool isDBusStubAdapterUnregistered = dbusObjectManager->unregisterDBusStubAdapter(registeredDbusStubAdapter.get()); + const bool isDBusStubAdapterUnregistered = dbusObjectManager->unregisterDBusStubAdapter(registeredDbusStubAdapter); assert(isDBusStubAdapterUnregistered); dbusConnection->releaseServiceName(dbusServiceName); diff --git a/src/CommonAPI/DBus/DBusStubAdapter.cpp b/src/CommonAPI/DBus/DBusStubAdapter.cpp index d0367b3..eb187ef 100644 --- a/src/CommonAPI/DBus/DBusStubAdapter.cpp +++ b/src/CommonAPI/DBus/DBusStubAdapter.cpp @@ -24,7 +24,7 @@ DBusStubAdapter::DBusStubAdapter(const std::shared_ptr& factory, const std::string& dbusBusName, const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection, - DBusObjectManagerStub* managerStub) : + const bool isManagingInterface) : factory_(factory), commonApiDomain_(split(commonApiAddress, ':')[0]), commonApiServiceId_(split(commonApiAddress, ':')[1]), @@ -33,7 +33,7 @@ DBusStubAdapter::DBusStubAdapter(const std::shared_ptr& factory, dbusBusName_(dbusBusName), dbusObjectPath_(dbusObjectPath), dbusConnection_(dbusConnection), - managerStub(managerStub) { + isManagingInterface_(isManagingInterface) { assert(!dbusBusName_.empty()); assert(!dbusInterfaceName_.empty()); diff --git a/src/CommonAPI/DBus/DBusStubAdapter.h b/src/CommonAPI/DBus/DBusStubAdapter.h index 7c365af..ec73067 100644 --- a/src/CommonAPI/DBus/DBusStubAdapter.h +++ b/src/CommonAPI/DBus/DBusStubAdapter.h @@ -35,7 +35,7 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter, public DBusInterfa const std::string& dbusBusName, const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection, - DBusObjectManagerStub* managerStub = NULL); + const bool isManagingInterface); virtual ~DBusStubAdapter(); @@ -53,8 +53,7 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter, public DBusInterfa inline const std::shared_ptr& getDBusConnection() const; - inline virtual DBusObjectManagerStub* getDBusObjectManagerStub(); - inline const bool hasDBusObjectManagerStub(); + inline const bool isManagingInterface(); virtual const char* getMethodsDBusIntrospectionXmlData() const = 0; virtual bool onInterfaceDBusMessage(const DBusMessage& dbusMessage) = 0; @@ -72,20 +71,16 @@ class DBusStubAdapter: virtual public CommonAPI::StubAdapter, public DBusInterfa const std::string dbusInterfaceName_; const std::shared_ptr dbusConnection_; - DBusObjectManagerStub* managerStub; - static const std::string domain_; const std::shared_ptr factory_; -}; + const bool isManagingInterface_; +}; -DBusObjectManagerStub* DBusStubAdapter::getDBusObjectManagerStub() { - return managerStub; -} -const bool DBusStubAdapter::hasDBusObjectManagerStub() { - return (getDBusObjectManagerStub() != NULL); +const bool DBusStubAdapter::isManagingInterface() { + return isManagingInterface_; } const std::string& DBusStubAdapter::getDBusName() const { diff --git a/src/CommonAPI/DBus/DBusStubAdapterHelper.h b/src/CommonAPI/DBus/DBusStubAdapterHelper.h index 9507214..54f246a 100644 --- a/src/CommonAPI/DBus/DBusStubAdapterHelper.h +++ b/src/CommonAPI/DBus/DBusStubAdapterHelper.h @@ -47,8 +47,8 @@ class DBusStubAdapterHelper: public DBusStubAdapter, public std::enable_shared_f const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection, const std::shared_ptr<_StubClass>& stub, - DBusObjectManagerStub* managerStub = NULL): - DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, managerStub), + const bool isManagingInterface): + DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, isManagingInterface), stub_(stub) { } diff --git a/src/test/DBusCommunicationTest.cpp b/src/test/DBusCommunicationTest.cpp index 2ecb697..4f4bb06 100644 --- a/src/test/DBusCommunicationTest.cpp +++ b/src/test/DBusCommunicationTest.cpp @@ -336,12 +336,12 @@ class DBusLowLevelCommunicationTest: public ::testing::Test { dbusStubAdapter = std::make_shared(dummy, commonApiAddress, interfaceName, connectionName, objectPath, dbusConnection, stub); dbusStubAdapter->init(); - CommonAPI::DBus::DBusObjectManagerStub& rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub(); + std::shared_ptr rootDBusObjectManagerStub = dbusConnection->getDBusObjectManager()->getRootDBusObjectManagerStub(); const auto dbusObjectManager = dbusConnection->getDBusObjectManager(); - const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(dbusStubAdapter.get()); + const bool isDBusObjectRegistrationSuccessful = dbusObjectManager->registerDBusStubAdapter(dbusStubAdapter); - const bool isServiceExportSuccessful = rootDBusObjectManagerStub.exportDBusStubAdapter(dbusStubAdapter.get()); + const bool isServiceExportSuccessful = rootDBusObjectManagerStub->exportManagedDBusStubAdapter(dbusStubAdapter); return dbusStubAdapter; } diff --git a/src/test/DBusManagedTest.cpp b/src/test/DBusManagedTest.cpp index bbbcef2..16e74a7 100644 --- a/src/test/DBusManagedTest.cpp +++ b/src/test/DBusManagedTest.cpp @@ -24,31 +24,53 @@ #include "commonapi/tests/managed/RootInterfaceStubDefault.h" #include "commonapi/tests/managed/LeafInterfaceStubDefault.h" +#include "commonapi/tests/managed/RootInterfaceProxy.h" #include "commonapi/tests/managed/RootInterfaceDBusProxy.h" #include "commonapi/tests/managed/LeafInterfaceProxy.h" - #include #include #include #include -static const std::string rootAddress = "local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterface"; +static const std::string rootAddress = + "local:commonapi.tests.managed.RootInterface:commonapi.tests.managed.RootInterface"; static const std::string leafInstance = "commonapi.tests.managed.RootInterface.LeafInterface"; static const std::string leafAddress = "local:commonapi.tests.managed.LeafInterface:" + leafInstance; static const std::string dbusServiceName = "CommonAPI.DBus.DBusObjectManagerStubTest"; -static const std::string& dbusObjectManagerStubPath = "/commonapi/dbus/test/DBusObjectManagerStub"; -static const std::string& managedDBusObjectPathPrefix = "/commonapi/dbus/test/DBusObjectManagerStub/ManagedObject"; + +static const std::string rootInterfaceName = "/commonapi/tests/managed/RootInterface"; +static const std::string rootObjectPath = "/commonapi/tests/managed/RootInterface"; + + +const CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict getManagedObjects(const std::string& dbusObjectPath, + std::shared_ptr connection) { + auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall( + dbusServiceName, + dbusObjectPath, + CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName(), + "GetManagedObjects"); + + CommonAPI::DBus::DBusError dbusError; + auto dbusMessageReply = connection->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError); + + CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply); + + CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; + dbusInputStream >> dbusObjectPathAndInterfacesDict; + + return dbusObjectPathAndInterfacesDict; +} class DBusManagedTest: public ::testing::Test { - protected: +protected: virtual void SetUp() { - leafStatus = CommonAPI::AvailabilityStatus::UNKNOWN; - runtime = std::dynamic_pointer_cast(CommonAPI::Runtime::load()); - serviceFactory = std::dynamic_pointer_cast(runtime->createFactory()); - clientFactory = std::dynamic_pointer_cast(runtime->createFactory()); + leafStatus_ = CommonAPI::AvailabilityStatus::UNKNOWN; + runtime_ = std::dynamic_pointer_cast(CommonAPI::Runtime::load()); + serviceFactory = std::dynamic_pointer_cast(runtime_->createFactory()); + clientFactory = std::dynamic_pointer_cast(runtime_->createFactory()); proxyDBusConnection_ = CommonAPI::DBus::DBusConnection::getSessionBus(); ASSERT_TRUE(proxyDBusConnection_->connect()); @@ -60,7 +82,7 @@ class DBusManagedTest: public ::testing::Test { } virtual void TearDown() { - runtime->getServicePublisher()->unregisterService(rootAddress); + runtime_->getServicePublisher()->unregisterService(rootAddress); stubDBusConnection_->disconnect(); stubDBusConnection_.reset(); @@ -69,105 +91,57 @@ class DBusManagedTest: public ::testing::Test { proxyDBusConnection_.reset(); } - std::shared_ptr runtime; + std::shared_ptr runtime_; std::shared_ptr serviceFactory; std::shared_ptr clientFactory; - CommonAPI::AvailabilityStatus leafStatus; - - void getManagedObjects(const std::string& dbusObjectPath, - CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict) { - auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall( - dbusServiceName, - dbusObjectPath, - CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName(), - "GetManagedObjects"); - - CommonAPI::DBus::DBusError dbusError; - auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError); - - ASSERT_FALSE(dbusError) << dbusError.getMessage(); - ASSERT_TRUE(dbusMessageReply.isMethodReturnType()); - ASSERT_TRUE(dbusMessageReply.hasSignature("a{oa{sa{sv}}}")); - - CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply); - - dbusInputStream >> dbusObjectPathAndInterfacesDict; - ASSERT_FALSE(dbusInputStream.hasError()); - } - - void getIntrospectionData(const std::string& dbusObjectPath, std::string& introspectionDataXml) { - auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall( - dbusServiceName, - dbusObjectPath, - "org.freedesktop.DBus.Introspectable", - "Introspect"); - CommonAPI::DBus::DBusError dbusError; - auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError); - - ASSERT_FALSE(dbusError) << dbusError.getMessage(); - ASSERT_TRUE(dbusMessageReply.isMethodReturnType()); - ASSERT_TRUE(dbusMessageReply.hasSignature("s")); - - CommonAPI::DBus::DBusInputStream dbusInputStream(dbusMessageReply); - - dbusInputStream >> introspectionDataXml; - ASSERT_FALSE(dbusInputStream.hasError()); - } - std::shared_ptr proxyDBusConnection_; std::shared_ptr stubDBusConnection_; - public: - //Callback on singnal... - void managedObjectSignalled(std::string address, CommonAPI::AvailabilityStatus status) { - //ASSERT_EQ(address, leafAddress); - leafStatus = status; - } + CommonAPI::AvailabilityStatus leafStatus_; +public: + void managedObjectSignalled(std::string address, CommonAPI::AvailabilityStatus status) { + leafStatus_ = status; + } }; TEST_F(DBusManagedTest, RegisterRoot) { auto rootStub = std::make_shared(); - runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); + runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); - CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - getManagedObjects("/", dbusObjectPathAndInterfacesDict); + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_); EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty()); - runtime->getServicePublisher()->unregisterService(rootAddress); + runtime_->getServicePublisher()->unregisterService(rootAddress); } - TEST_F(DBusManagedTest, RegisterLeafUnmanaged) { auto leafStub = std::make_shared(); - runtime->getServicePublisher()->registerService(leafStub, leafAddress, serviceFactory); + runtime_->getServicePublisher()->registerService(leafStub, leafAddress, serviceFactory); - CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - getManagedObjects("/", dbusObjectPathAndInterfacesDict); + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_); EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty()); - runtime->getServicePublisher()->unregisterService(leafAddress); + runtime_->getServicePublisher()->unregisterService(leafAddress); } TEST_F(DBusManagedTest, RegisterLeafManaged) { - const char* rootInterfaceName = "/commonapi/tests/managed/RootInterface"; - const char* rootObjectPath = "/commonapi/tests/managed/RootInterface"; - auto rootStub = std::make_shared(); - runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); + runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); std::shared_ptr rootProxy = std::make_shared< commonapi::tests::managed::RootInterfaceDBusProxy>( - clientFactory, - rootAddress, - rootInterfaceName, - dbusServiceName, - rootObjectPath, - proxyDBusConnection_ + clientFactory, + rootAddress, + rootInterfaceName, + dbusServiceName, + rootObjectPath, + proxyDBusConnection_ ); + rootProxy->init(); for (uint32_t i = 0; !rootProxy->isAvailable() && i < 200; ++i) { @@ -178,61 +152,55 @@ TEST_F(DBusManagedTest, RegisterLeafManaged) { CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface(); proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe( std::bind(&DBusManagedTest::managedObjectSignalled, - this, - std::placeholders::_1, - std::placeholders::_2)); + this, + std::placeholders::_1, + std::placeholders::_2)); auto leafStub = std::make_shared(); bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); ASSERT_TRUE(reg); - for (uint32_t i = 0; leafStatus != CommonAPI::AvailabilityStatus::AVAILABLE && i < 50; ++i) { - usleep(1000); + for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::AVAILABLE && i < 50; ++i) { + usleep(10 * 1000); } - ASSERT_TRUE(leafStatus == CommonAPI::AvailabilityStatus::AVAILABLE); - - CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; + ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::AVAILABLE); - getManagedObjects("/", dbusObjectPathAndInterfacesDict); + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_); ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty()); dbusObjectPathAndInterfacesDict.clear(); - getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict); + dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_); ASSERT_FALSE(dbusObjectPathAndInterfacesDict.empty()); bool deregistered = rootStub->deregisterManagedStubLeafInterface(leafInstance); - ASSERT_TRUE(deregistered); + EXPECT_TRUE(deregistered); - for (uint32_t i = 0; leafStatus != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) { + for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 200; ++i) { usleep(10 * 1000); } - ASSERT_TRUE(leafStatus == CommonAPI::AvailabilityStatus::NOT_AVAILABLE); + EXPECT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE); - dbusObjectPathAndInterfacesDict.clear(); - getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict); - ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); + dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_); + EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); - runtime->getServicePublisher()->unregisterService(rootAddress); - dbusObjectPathAndInterfacesDict.clear(); - getManagedObjects("/", dbusObjectPathAndInterfacesDict); - ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); + runtime_->getServicePublisher()->unregisterService(rootAddress); + dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_); + EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); } TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) { - const char* rootInterfaceName = "/commonapi/tests/managed/RootInterface"; - const char* rootObjectPath = "/commonapi/tests/managed/RootInterface"; - auto rootStub = std::make_shared(); - runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); + bool success = runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); + ASSERT_TRUE(success); std::shared_ptr rootProxy = std::make_shared< commonapi::tests::managed::RootInterfaceDBusProxy>( - clientFactory, - rootAddress, - rootInterfaceName, - dbusServiceName, - rootObjectPath, - proxyDBusConnection_ + clientFactory, + rootAddress, + rootInterfaceName, + dbusServiceName, + rootObjectPath, + proxyDBusConnection_ ); rootProxy->init(); @@ -242,11 +210,16 @@ TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) { ASSERT_TRUE(rootProxy->isAvailable()); CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface(); - proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(std::bind(&DBusManagedTest::managedObjectSignalled, this, std::placeholders::_1, std::placeholders::_2)); + proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe( + std::bind( + &DBusManagedTest::managedObjectSignalled, + this, + std::placeholders::_1, + std::placeholders::_2)); auto leafStub = std::make_shared(); - bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); - ASSERT_TRUE(reg); + success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); + ASSERT_TRUE(success); sleep(2); @@ -263,37 +236,35 @@ TEST_F(DBusManagedTest, RegisterLeafManagedAndCreateProxyForLeaf) { std::string outString; leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString); - ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS); + EXPECT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS); - bool dereg = rootStub->deregisterManagedStubLeafInterface(leafInstance); + success = rootStub->deregisterManagedStubLeafInterface(leafInstance); + EXPECT_TRUE(success); - CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - dbusObjectPathAndInterfacesDict.clear(); - getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict); - ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); + auto dbusObjectPathAndInterfacesDict = getManagedObjects(rootInterfaceName, proxyDBusConnection_); + EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); - runtime->getServicePublisher()->unregisterService(rootAddress); - dbusObjectPathAndInterfacesDict.clear(); - getManagedObjects("/", dbusObjectPathAndInterfacesDict); - ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); + success = runtime_->getServicePublisher()->unregisterService(rootAddress); + EXPECT_TRUE(success); + + dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_); + EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); } TEST_F(DBusManagedTest, PropagateTeardown) { - const char* rootInterfaceName = "/commonapi/tests/managed/RootInterface"; - const char* rootObjectPath = "/commonapi/tests/managed/RootInterface"; - auto rootStub = std::make_shared(); - runtime->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); + bool success = runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory); + ASSERT_TRUE(success); std::shared_ptr rootProxy = std::make_shared< commonapi::tests::managed::RootInterfaceDBusProxy>( - clientFactory, - rootAddress, - rootInterfaceName, - dbusServiceName, - rootObjectPath, - proxyDBusConnection_ + clientFactory, + rootAddress, + rootInterfaceName, + dbusServiceName, + rootObjectPath, + proxyDBusConnection_ ); rootProxy->init(); @@ -303,7 +274,12 @@ TEST_F(DBusManagedTest, PropagateTeardown) { ASSERT_TRUE(rootProxy->isAvailable()); CommonAPI::ProxyManager& proxyManagerLeafInterface = rootProxy->getProxyManagerLeafInterface(); - proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe(std::bind(&DBusManagedTest::managedObjectSignalled, this, std::placeholders::_1, std::placeholders::_2)); + proxyManagerLeafInterface.getInstanceAvailabilityStatusChangedEvent().subscribe( + std::bind( + &DBusManagedTest::managedObjectSignalled, + this, + std::placeholders::_1, + std::placeholders::_2)); auto leafStub = std::make_shared(); bool reg = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); @@ -327,23 +303,269 @@ TEST_F(DBusManagedTest, PropagateTeardown) { ASSERT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS); - bool dereg = runtime->getServicePublisher()->unregisterService(rootAddress); + bool dereg = runtime_->getServicePublisher()->unregisterService(rootAddress); ASSERT_TRUE(dereg); - for (uint32_t i = 0; leafStatus != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 100; ++i) { + for (uint32_t i = 0; leafStatus_ != CommonAPI::AvailabilityStatus::NOT_AVAILABLE && i < 100; ++i) { usleep(10 * 1000); } - ASSERT_TRUE(leafStatus == CommonAPI::AvailabilityStatus::NOT_AVAILABLE); + ASSERT_TRUE(leafStatus_ == CommonAPI::AvailabilityStatus::NOT_AVAILABLE); - CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - dbusObjectPathAndInterfacesDict.clear(); - getManagedObjects("/", dbusObjectPathAndInterfacesDict); + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", proxyDBusConnection_); ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); } +class DBusManagedTestExtended: public ::testing::Test { +protected: + virtual void SetUp() { + runtime_ = std::dynamic_pointer_cast(CommonAPI::Runtime::load()); + serviceFactory_ = runtime_->createFactory(); + clientFactory_ = runtime_->createFactory(); + + manualTestDBusConnection_ = CommonAPI::DBus::DBusConnection::getSessionBus(); + ASSERT_TRUE(manualTestDBusConnection_->connect()); + + auto dbusServiceFactory = std::dynamic_pointer_cast(serviceFactory_); + auto stubDBusConnection = dbusServiceFactory->getDbusConnection(); + ASSERT_TRUE(stubDBusConnection->connect()); + ASSERT_TRUE(stubDBusConnection->requestServiceNameAndBlock(dbusServiceName)); + } + + virtual void TearDown() { + for (auto it: rootStubs_) { + runtime_->getServicePublisher()->unregisterService(it.first); + } + + rootStubs_.clear(); + rootProxies_.clear(); + + auto dbusServiceFactory = std::dynamic_pointer_cast(serviceFactory_); + auto stubDBusConnection = dbusServiceFactory->getDbusConnection(); + ASSERT_TRUE(stubDBusConnection->releaseServiceName(dbusServiceName)); + + usleep(50000); + } + + inline const std::string getSuffixedRootAddress(const std::string& suffix) { + return "local:commonapi.tests.managed.RootInterface" + suffix + ":commonapi.tests.managed.RootInterface"; + } + + inline const bool registerRootStubForSuffix(const std::string& suffix) { + std::shared_ptr rootStub = std::make_shared< + commonapi::tests::managed::RootInterfaceStubDefault>(); + const std::string rootAddress = getSuffixedRootAddress(suffix); + rootStubs_.insert( {rootAddress, rootStub} ); + return runtime_->getServicePublisher()->registerService(rootStub, rootAddress, serviceFactory_); + } + + inline void createRootProxyForSuffix(const std::string& suffix) { + rootProxies_.push_back(clientFactory_->buildProxy(getSuffixedRootAddress(suffix))); + } + + template + bool waitForAllProxiesToBeAvailable(const std::vector<_ProxyType>& dbusProxies) { + bool allAreAvailable = false; + for (size_t i = 0; i < 200 && !allAreAvailable; i++) { + allAreAvailable = std::all_of( + dbusProxies.begin(), + dbusProxies.end(), + [](const _ProxyType& proxy) { + return proxy->isAvailable(); + }); + usleep(10 * 1000); + } + return allAreAvailable; + } + + bool registerXLeafStubsForAllRoots(uint32_t x, bool doSubscriptionsForLeafNotifications) { + bool success = true; + bool expectedValueForRegistration = true; + for (auto rootStubIterator: rootStubs_) { + if (doSubscriptionsForLeafNotifications) { + // CommonAPI::ProxyManager& proxyManagerForLeafInterface = rootManagerProxyArray[i]->getProxyManagerLeafInterface(); + // auto subscription = subscribeWithAvailabilityFlag(proxyManagerForLeafInterface, stati[i]); + // subscriptions.push_back(subscription); + } + for (uint32_t i = 0; i < x; i++) { + std::shared_ptr leafStub = std::make_shared< + commonapi::tests::managed::LeafInterfaceStubDefault>(); + success &= (rootStubIterator.second->registerManagedStubLeafInterfaceAutoInstance(leafStub) == expectedValueForRegistration); + } + //As all root interfaces are registered on the same object path, the leaf interfaces also will be registered with + //this same object path as base. The first set of leaf interfaces therefore will be registered successfully. + //The second and third set of leaf interfaces use a different object manager that does not know about the already + //registered leaf interfaces, and therefore tries to register the same names on the same object paths again. + //As of now, this will fail. + expectedValueForRegistration = false; + } + return success; + } + + void createXLeafProxiesForAllExistingLeafs() { + for (auto rootProxyIterator: rootProxies_) { + std::vector>> leafProxiesForRootX; + + CommonAPI::ProxyManager& leafProxyManager = rootProxyIterator->getProxyManagerLeafInterface(); + std::vector availableInstances; + CommonAPI::CallStatus status; + leafProxyManager.getAvailableInstances(status, availableInstances); + + for (const std::string& availableInstance: availableInstances) { + auto newLeafProxy = leafProxyManager.buildProxy(availableInstance); + leafProxiesForRootX.push_back(newLeafProxy); + } + leafProxies_.push_back(std::move(leafProxiesForRootX)); + } + } + + std::shared_ptr runtime_; + std::shared_ptr serviceFactory_; + std::shared_ptr clientFactory_; + + std::shared_ptr manualTestDBusConnection_; + + std::unordered_map> rootStubs_; + std::vector>> rootProxies_; + std::vector>>> leafProxies_; +}; + + +TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPath) { + ASSERT_TRUE(registerRootStubForSuffix("One")); + ASSERT_TRUE(registerRootStubForSuffix("Two")); + ASSERT_TRUE(registerRootStubForSuffix("Three")); + + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_); + EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty()); +} + + +TEST_F(DBusManagedTestExtended, RegisterSeveralRootsOnSameObjectPathAndCommunicate) { + ASSERT_TRUE(registerRootStubForSuffix("One")); + ASSERT_TRUE(registerRootStubForSuffix("Two")); + ASSERT_TRUE(registerRootStubForSuffix("Three")); + + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_); + EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty()); + + createRootProxyForSuffix("One"); + createRootProxyForSuffix("Two"); + createRootProxyForSuffix("Three"); + + bool allRootProxiesAreAvailable = waitForAllProxiesToBeAvailable(rootProxies_); + ASSERT_TRUE(allRootProxiesAreAvailable); + + CommonAPI::CallStatus callStatus; + commonapi::tests::managed::RootInterface::testRootMethodError applicationError; + int32_t outInt; + std::string outString; + + for (size_t i = 0; i < rootProxies_.size(); ++i) { + rootProxies_[i]->testRootMethod( + -5, + std::string("More Cars"), + callStatus, + applicationError, + outInt, + outString); + EXPECT_EQ(CommonAPI::CallStatus::SUCCESS, callStatus); + } +} + +TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPath) { + ASSERT_TRUE(registerRootStubForSuffix("One")); + ASSERT_TRUE(registerRootStubForSuffix("Two")); + ASSERT_TRUE(registerRootStubForSuffix("Three")); + + bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5, false); + ASSERT_TRUE(allLeafStubsWereRegistered); + + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_); + EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty()); +} + +TEST_F(DBusManagedTestExtended, RegisterSeveralRootsAndSeveralLeafsForEachOnSameObjectPathAndCommunicate) { + ASSERT_TRUE(registerRootStubForSuffix("One")); + ASSERT_TRUE(registerRootStubForSuffix("Two")); + ASSERT_TRUE(registerRootStubForSuffix("Three")); + + bool allLeafStubsWereRegistered = registerXLeafStubsForAllRoots(5, false); + ASSERT_TRUE(allLeafStubsWereRegistered); + + auto dbusObjectPathAndInterfacesDict = getManagedObjects("/", manualTestDBusConnection_); + EXPECT_FALSE(dbusObjectPathAndInterfacesDict.empty()); + + createRootProxyForSuffix("One"); + createRootProxyForSuffix("Two"); + createRootProxyForSuffix("Three"); + + //Check on existence of leaf-stubs + + bool allRootProxiesAreAvailable = waitForAllProxiesToBeAvailable(rootProxies_); + ASSERT_TRUE(allRootProxiesAreAvailable); + + usleep(500 * 1000); + + createXLeafProxiesForAllExistingLeafs(); + + usleep(500 * 1000); + + ASSERT_EQ(3, leafProxies_.size()); + + uint32_t runNr = 1; + for (const auto& leafProxiesForCurrentRoot: leafProxies_) { + ASSERT_EQ(5, leafProxiesForCurrentRoot.size()) << "in run #" << runNr++; + + bool allLeafProxiesForCurrentRootAreAvailable = waitForAllProxiesToBeAvailable(leafProxiesForCurrentRoot); + EXPECT_TRUE(allLeafProxiesForCurrentRootAreAvailable); + + ++runNr; + } + +// CommonAPI::AvailabilityStatus stati[3]; +// std::vector subscriptions; + + // auto leafStub = std::make_shared(); + // bool success = rootStub->registerManagedStubLeafInterface(leafStub, leafInstance); + // ASSERT_TRUE(success); + // + // sleep(2); + // + // auto leafProxy = proxyManagerLeafInterface.buildProxy(leafInstance); + // for (uint32_t i = 0; !leafProxy->isAvailable() && i < 500; ++i) { + // usleep(10 * 1000); + // } + // + // ASSERT_TRUE(leafProxy->isAvailable()); + // + // CommonAPI::CallStatus callStatus; + // commonapi::tests::managed::LeafInterface::testLeafMethodError error; + // int outInt; + // std::string outString; + // leafProxy->testLeafMethod(42, "Test", callStatus, error, outInt, outString); + // + // EXPECT_TRUE(callStatus == CommonAPI::CallStatus::SUCCESS); + // + // success = rootStub->deregisterManagedStubLeafInterface(leafInstance); + // EXPECT_TRUE(success); + // + // CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; + // dbusObjectPathAndInterfacesDict.clear(); + // getManagedObjects(rootInterfaceName, dbusObjectPathAndInterfacesDict); + // EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); + // + // success = runtime->getServicePublisher()->unregisterService(rootAddress); + // EXPECT_TRUE(success); + // + // dbusObjectPathAndInterfacesDict.clear(); + // getManagedObjects("/", dbusObjectPathAndInterfacesDict); + // EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); +} + //XXX: Needs tests for invalid instances for the children. //XXX: Also later on need auto generated instance ID test and -//XXX: Also check transitive teardown +//XXX: If stub cannot manage, ensure the objectManager interface does not appear on dbus +//XXX: Tests if configuration file is present int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); diff --git a/src/test/DBusObjectManagerStubTest.cpp b/src/test/DBusObjectManagerStubTest.cpp index 1df20bf..cd14d74 100644 --- a/src/test/DBusObjectManagerStubTest.cpp +++ b/src/test/DBusObjectManagerStubTest.cpp @@ -24,22 +24,24 @@ #include #include - static const std::string dbusServiceName = "CommonAPI.DBus.DBusObjectManagerStubTest"; static const std::string& dbusObjectManagerStubPath = "/commonapi/dbus/test/DBusObjectManagerStub"; static const std::string& managedDBusObjectPathPrefix = "/commonapi/dbus/test/DBusObjectManagerStub/ManagedObject"; - class TestDBusStubAdapter: public CommonAPI::DBus::DBusStubAdapter { - public: +public: TestDBusStubAdapter(const std::shared_ptr factory, const std::string& dbusObjectPath, - const std::shared_ptr& dbusConnection) : - DBusStubAdapter(factory, "local:" + dbusServiceName + ":commonapi.dbus.tests.TestDBusStubAdapter-" + dbusObjectPath, + const std::shared_ptr& dbusConnection, + const bool isManagingInterface) : + DBusStubAdapter( + factory, + "local:" + dbusServiceName + ":commonapi.dbus.tests.TestDBusStubAdapter-" + dbusObjectPath, "commonapi.dbus.tests.TestDBusStubAdapter", dbusServiceName, dbusObjectPath, - dbusConnection) { + dbusConnection, + isManagingInterface) { } void deactivateManagedInstances() { @@ -54,41 +56,38 @@ class TestDBusStubAdapter: public CommonAPI::DBus::DBusStubAdapter { return false; } - - - protected: +protected: TestDBusStubAdapter(const std::shared_ptr factory, - const std::string& dbusObjectPath, + const std::string& dbusObjectPath, const std::string& dbusInterfaceName, - const std::shared_ptr& dbusConnection) : - DBusStubAdapter(factory, "local:" + dbusServiceName + ":" + dbusInterfaceName + "-" + dbusObjectPath, + const std::shared_ptr& dbusConnection, + const bool isManagingInterface) : + DBusStubAdapter( + factory, + "local:" + dbusServiceName + ":" + dbusInterfaceName + "-" + dbusObjectPath, dbusInterfaceName, dbusServiceName, dbusObjectPath, - dbusConnection) { + dbusConnection, + isManagingInterface) { } - }; - class ManagerTestDBusStubAdapter: public TestDBusStubAdapter { - public: - ManagerTestDBusStubAdapter(const std::shared_ptr factory, const std::string& dbusObjectPath, +public: + ManagerTestDBusStubAdapter(const std::shared_ptr factory, + const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection) : - TestDBusStubAdapter(factory, dbusObjectPath, "commonapi.dbus.tests.ManagerTestDBusStubAdapter", dbusConnection), - dbusObjectManagerStub_(dbusObjectPath, dbusConnection) { - } - - virtual CommonAPI::DBus::DBusObjectManagerStub* getDBusObjectManagerStub() { - return &dbusObjectManagerStub_; + TestDBusStubAdapter( + factory, + dbusObjectPath, + "commonapi.dbus.tests.ManagerTestDBusStubAdapter", + dbusConnection, + true) { } - - private: - CommonAPI::DBus::DBusObjectManagerStub dbusObjectManagerStub_; }; - struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnection::DBusSignalHandler { size_t totalAddedCount; size_t totalRemovedCount; @@ -99,7 +98,6 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio std::condition_variable signalReceived; std::mutex lock; - ~TestDBusObjectManagerSignalHandler() { dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerAddedToken_); dbusConnection_->removeSignalMemberHandler(dbusSignalHandlerRemovedToken_); @@ -131,14 +129,15 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio } static inline std::shared_ptr create( - const std::string& dbusObjectPath, - const std::shared_ptr& dbusConnection) { + const std::string& dbusObjectPath, + const std::shared_ptr< + CommonAPI::DBus::DBusProxyConnection>& dbusConnection) { auto dbusSignalHandler = new TestDBusObjectManagerSignalHandler(dbusObjectPath, dbusConnection); dbusSignalHandler->init(); return std::shared_ptr(dbusSignalHandler); } - private: +private: TestDBusObjectManagerSignalHandler(const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection) : dbusObjectPath_(dbusObjectPath), @@ -169,9 +168,8 @@ struct TestDBusObjectManagerSignalHandler: public CommonAPI::DBus::DBusConnectio CommonAPI::DBus::DBusProxyConnection::DBusSignalHandlerToken dbusSignalHandlerRemovedToken_; }; - class DBusObjectManagerStubTest: public ::testing::Test { - protected: +protected: virtual void SetUp() { auto runtime = std::dynamic_pointer_cast(CommonAPI::Runtime::load()); serviceFactory = std::dynamic_pointer_cast(runtime->createFactory()); @@ -185,15 +183,15 @@ class DBusObjectManagerStubTest: public ::testing::Test { ASSERT_TRUE(stubDBusConnection_->requestServiceNameAndBlock(dbusServiceName)); } - virtual void TearDown() { - stubDBusConnection_->disconnect(); - stubDBusConnection_.reset(); + virtual void TearDown() { + stubDBusConnection_->disconnect(); + stubDBusConnection_.reset(); - proxyDBusConnection_->disconnect(); - proxyDBusConnection_.reset(); - } + proxyDBusConnection_->disconnect(); + proxyDBusConnection_.reset(); + } - std::shared_ptr serviceFactory; + std::shared_ptr serviceFactory; void getManagedObjects(const std::string& dbusObjectPath, CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict& dbusObjectPathAndInterfacesDict) { @@ -206,7 +204,7 @@ class DBusObjectManagerStubTest: public ::testing::Test { CommonAPI::DBus::DBusError dbusError; auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError); - ASSERT_FALSE(dbusError) << dbusError.getMessage(); + ASSERT_FALSE(dbusError)<< dbusError.getMessage(); ASSERT_TRUE(dbusMessageReply.isMethodReturnType()); ASSERT_TRUE(dbusMessageReply.hasSignature("a{oa{sa{sv}}}")); @@ -225,7 +223,7 @@ class DBusObjectManagerStubTest: public ::testing::Test { CommonAPI::DBus::DBusError dbusError; auto dbusMessageReply = proxyDBusConnection_->sendDBusMessageWithReplyAndBlock(dbusMessageCall, dbusError); - ASSERT_FALSE(dbusError) << dbusError.getMessage(); + ASSERT_FALSE(dbusError)<< dbusError.getMessage(); ASSERT_TRUE(dbusMessageReply.isMethodReturnType()); ASSERT_TRUE(dbusMessageReply.hasSignature("s")); @@ -244,11 +242,12 @@ class DBusObjectManagerStubTest: public ::testing::Test { auto waitResult = dbusSignalHandler->signalReceived.wait_for( lock, std::chrono::milliseconds(interfacesAddedCount * waitMillisecondsPerInterface), - [&]() { return dbusSignalHandler->totalAddedCount == interfacesAddedCount; }); + [&]() {return dbusSignalHandler->totalAddedCount == interfacesAddedCount;}); ASSERT_TRUE(waitResult); ASSERT_EQ(dbusSignalHandler->totalRemovedCount, interfacesRemovedExpectedCount); - const std::string lastAddedDBusObjectPath = managedDBusObjectPathPrefix + std::to_string(interfacesAddedCount - 1); + const std::string lastAddedDBusObjectPath = managedDBusObjectPathPrefix + + std::to_string(interfacesAddedCount - 1); ASSERT_TRUE(dbusSignalHandler->lastAddedDBusObjectPath == lastAddedDBusObjectPath); } @@ -261,20 +260,22 @@ class DBusObjectManagerStubTest: public ::testing::Test { auto waitResult = dbusSignalHandler->signalReceived.wait_for( lock, std::chrono::milliseconds(interfacesRemovedCount * waitMillisecondsPerInterface), - [&]() { return dbusSignalHandler->totalRemovedCount == interfacesRemovedCount; }); + [&]() {return dbusSignalHandler->totalRemovedCount == interfacesRemovedCount;}); ASSERT_TRUE(waitResult); ASSERT_EQ(dbusSignalHandler->totalAddedCount, interfacesAddedExpectedCount); - const std::string lastRemovedDBusObjectPath = managedDBusObjectPathPrefix + std::to_string(interfacesRemovedCount - 1); + const std::string lastRemovedDBusObjectPath = managedDBusObjectPathPrefix + + std::to_string(interfacesRemovedCount - 1); ASSERT_TRUE(dbusSignalHandler->lastRemovedDBusObjectPath == lastRemovedDBusObjectPath); } - template - void createDBusStubAdapter(std::array, _ArraySize>& dbusStubAdapter) { + template + void createDBusStubAdapterArray(std::array, _ArraySize>& dbusStubAdapter) { for (size_t i = 0; i < _ArraySize; i++) { dbusStubAdapter[i] = std::make_shared<_StubType>(serviceFactory, managedDBusObjectPathPrefix + std::to_string(i), - stubDBusConnection_); + stubDBusConnection_, + false); ASSERT_TRUE(bool(dbusStubAdapter[i])); @@ -310,7 +311,7 @@ TEST_F(DBusObjectManagerStubTest, RootRegisterStubAdapterWorks) { auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create("/", proxyDBusConnection_); std::array, 10> dbusStubAdapterArray; - createDBusStubAdapter(dbusStubAdapterArray); + createDBusStubAdapterArray(dbusStubAdapterArray); const bool isServiceRegistrationSuccessful = std::all_of( dbusStubAdapterArray.begin(), @@ -341,9 +342,13 @@ TEST_F(DBusObjectManagerStubTest, RootRegisterStubAdapterWorks) { ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); } + TEST_F(DBusObjectManagerStubTest, RegisterManagerStubAdapterWorks) { CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - auto managerDBusStubAdapter = std::make_shared(serviceFactory, dbusObjectManagerStubPath, stubDBusConnection_); + auto managerDBusStubAdapter = std::make_shared( + serviceFactory, + dbusObjectManagerStubPath, + stubDBusConnection_); managerDBusStubAdapter->init(); ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter)); @@ -355,55 +360,68 @@ TEST_F(DBusObjectManagerStubTest, RegisterManagerStubAdapterWorks) { ASSERT_EQ(dbusObjectPathAndInterfacesDict.count(dbusObjectManagerStubPath), 1); ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].size(), 2); - ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count(CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName()), 1); - ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count(managerDBusStubAdapter->getInterfaceName()), 1); + ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count( + CommonAPI::DBus::DBusObjectManagerStub::getInterfaceName()), + 1); + ASSERT_EQ(dbusObjectPathAndInterfacesDict[dbusObjectManagerStubPath].count( + managerDBusStubAdapter->getInterfaceName()), + 1); - ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterService(managerDBusStubAdapter->getAddress())); + ASSERT_TRUE( + CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterService( + managerDBusStubAdapter->getAddress())); dbusObjectPathAndInterfacesDict.clear(); getManagedObjects("/", dbusObjectPathAndInterfacesDict); ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); } - TEST_F(DBusObjectManagerStubTest, ManagerStubAdapterExportAndUnexportWorks) { CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create(dbusObjectManagerStubPath, proxyDBusConnection_); - auto managerDBusStubAdapter = std::make_shared(serviceFactory, dbusObjectManagerStubPath, stubDBusConnection_); + auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create( + dbusObjectManagerStubPath, + proxyDBusConnection_); + auto managerDBusStubAdapter = std::make_shared( + serviceFactory, + dbusObjectManagerStubPath, + stubDBusConnection_); managerDBusStubAdapter->init(); ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter)); std::array, 10> dbusStubAdapterArray; - createDBusStubAdapter(dbusStubAdapterArray); - - const bool isServiceRegistrationSuccessful = std::all_of( - dbusStubAdapterArray.begin(), - dbusStubAdapterArray.end(), - [](const std::shared_ptr& dbusStubAdapter) { - return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); - }); + createDBusStubAdapterArray(dbusStubAdapterArray); + + const bool isServiceRegistrationSuccessful = + std::all_of( + dbusStubAdapterArray.begin(), + dbusStubAdapterArray.end(), + [](const std::shared_ptr& dbusStubAdapter) { + return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); + }); ASSERT_TRUE(isServiceRegistrationSuccessful); - const bool isServiceExportSuccessful = std::all_of( - dbusStubAdapterArray.begin(), - dbusStubAdapterArray.end(), - [&](const std::shared_ptr& dbusStubAdapter) { - return managerDBusStubAdapter->getDBusObjectManagerStub()->exportDBusStubAdapter(dbusStubAdapter.get()); - }); + const bool isServiceExportSuccessful = + std::all_of( + dbusStubAdapterArray.begin(), + dbusStubAdapterArray.end(), + [&](const std::shared_ptr& dbusStubAdapter) { + return stubDBusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(managerDBusStubAdapter->getObjectPath(), dbusStubAdapter); + }); ASSERT_TRUE(isServiceExportSuccessful); waitForInterfacesAdded(dbusSignalHandler, dbusStubAdapterArray.size(), 0); getManagedObjects(dbusObjectManagerStubPath, dbusObjectPathAndInterfacesDict); - ASSERT_EQ(dbusObjectPathAndInterfacesDict.size(), dbusStubAdapterArray.size()); - - const bool isServiceUnexportSuccessful = std::all_of( - dbusStubAdapterArray.begin(), - dbusStubAdapterArray.end(), - [&](const std::shared_ptr& dbusStubAdapter) { - return managerDBusStubAdapter->getDBusObjectManagerStub()->unexportDBusStubAdapter(dbusStubAdapter.get()); - }); + EXPECT_EQ(dbusObjectPathAndInterfacesDict.size(), dbusStubAdapterArray.size()); + + const bool isServiceUnexportSuccessful = + std::all_of( + dbusStubAdapterArray.begin(), + dbusStubAdapterArray.end(), + [&](const std::shared_ptr& dbusStubAdapter) { + return stubDBusConnection_->getDBusObjectManager()->unexportManagedDBusStubAdapter(managerDBusStubAdapter->getObjectPath(), dbusStubAdapter); + }); ASSERT_TRUE(isServiceUnexportSuccessful); const bool isServiceDeregistrationSuccessful = std::all_of( @@ -419,36 +437,44 @@ TEST_F(DBusObjectManagerStubTest, ManagerStubAdapterExportAndUnexportWorks) { dbusObjectPathAndInterfacesDict.clear(); getManagedObjects(dbusObjectManagerStubPath, dbusObjectPathAndInterfacesDict); - ASSERT_TRUE(dbusObjectPathAndInterfacesDict.empty()); + EXPECT_TRUE(dbusObjectPathAndInterfacesDict.empty()); ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterService(managerDBusStubAdapter->getAddress())); } + TEST_F(DBusObjectManagerStubTest, DestructorUnpublishingWorks) { CommonAPI::DBus::DBusObjectManagerStub::DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict; - auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create(dbusObjectManagerStubPath, proxyDBusConnection_); - auto managerDBusStubAdapter = std::make_shared(serviceFactory, dbusObjectManagerStubPath, stubDBusConnection_); + auto dbusSignalHandler = TestDBusObjectManagerSignalHandler::create( + dbusObjectManagerStubPath, + proxyDBusConnection_); + auto managerDBusStubAdapter = std::make_shared( + serviceFactory, + dbusObjectManagerStubPath, + stubDBusConnection_); managerDBusStubAdapter->init(); - ASSERT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter)); + EXPECT_TRUE(CommonAPI::DBus::DBusServicePublisher::getInstance()->registerService(managerDBusStubAdapter)); std::array, 10> dbusStubAdapterArray; - createDBusStubAdapter(dbusStubAdapterArray); - - const bool isServiceRegistrationSuccessful = std::all_of( - dbusStubAdapterArray.begin(), - dbusStubAdapterArray.end(), - [](const std::shared_ptr& dbusStubAdapter) { - return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); - }); + createDBusStubAdapterArray(dbusStubAdapterArray); + + const bool isServiceRegistrationSuccessful = + std::all_of( + dbusStubAdapterArray.begin(), + dbusStubAdapterArray.end(), + [](const std::shared_ptr& dbusStubAdapter) { + return CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); + }); ASSERT_TRUE(isServiceRegistrationSuccessful); - const bool isServiceExportSuccessful = std::all_of( - dbusStubAdapterArray.begin(), - dbusStubAdapterArray.end(), - [&](const std::shared_ptr& dbusStubAdapter) { - return managerDBusStubAdapter->getDBusObjectManagerStub()->exportDBusStubAdapter(dbusStubAdapter.get()); - }); + const bool isServiceExportSuccessful = + std::all_of( + dbusStubAdapterArray.begin(), + dbusStubAdapterArray.end(), + [&](const std::shared_ptr& dbusStubAdapter) { + return stubDBusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(managerDBusStubAdapter->getObjectPath(), dbusStubAdapter); + }); ASSERT_TRUE(isServiceExportSuccessful); waitForInterfacesAdded(dbusSignalHandler, dbusStubAdapterArray.size(), 0); diff --git a/src/test/DBusServiceRegistryTest.cpp b/src/test/DBusServiceRegistryTest.cpp index 9eb1c65..2f1043e 100644 --- a/src/test/DBusServiceRegistryTest.cpp +++ b/src/test/DBusServiceRegistryTest.cpp @@ -146,7 +146,7 @@ class TestDBusStubAdapter: public CommonAPI::DBus::DBusStubAdapter { const std::string& dbusBusName, const std::string& dbusObjectPath, const std::shared_ptr& dbusConnection): - DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection), + DBusStubAdapter(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, false), introspectionCount(0) { } diff --git a/src/test/commonapi/tests/managed/BranchInterface.h b/src/test/commonapi/tests/managed/BranchInterface.h index 80b5138..d2a1e28 100644 --- a/src/test/commonapi/tests/managed/BranchInterface.h +++ b/src/test/commonapi/tests/managed/BranchInterface.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp index f056c50..8a1e99e 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp +++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h index a5eac7b..bac635b 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h +++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusProxy.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp index b9c846b..fd16fca 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp +++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. @@ -40,8 +40,7 @@ BranchInterfaceDBusStubAdapter::BranchInterfaceDBusStubAdapter( const std::shared_ptr& stub): BranchInterfaceDBusStubAdapterHelper(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, std::dynamic_pointer_cast(stub), - NULL) - { + false) { } BranchInterfaceDBusStubAdapter::~BranchInterfaceDBusStubAdapter() { diff --git a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h index df42f7b..3ebce77 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h +++ b/src/test/commonapi/tests/managed/BranchInterfaceDBusStubAdapter.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceProxy.h b/src/test/commonapi/tests/managed/BranchInterfaceProxy.h index 9bbbc77..a0de1b6 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceProxy.h +++ b/src/test/commonapi/tests/managed/BranchInterfaceProxy.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h b/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h index 5a6a613..acd2931 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h +++ b/src/test/commonapi/tests/managed/BranchInterfaceProxyBase.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceStub.h b/src/test/commonapi/tests/managed/BranchInterfaceStub.h index 8f90cfa..0e4d397 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceStub.h +++ b/src/test/commonapi/tests/managed/BranchInterfaceStub.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp index 1fa2a8f..84e7567 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp +++ b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h index b2dab45..ae9945d 100644 --- a/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h +++ b/src/test/commonapi/tests/managed/BranchInterfaceStubDefault.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/LeafInterface.h b/src/test/commonapi/tests/managed/LeafInterface.h index 1aaad3d..2d99fe5 100644 --- a/src/test/commonapi/tests/managed/LeafInterface.h +++ b/src/test/commonapi/tests/managed/LeafInterface.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp index a87c019..665b655 100644 --- a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp +++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h index 8653db4..26ba6f9 100644 --- a/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h +++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusProxy.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp index 2ff0d48..9abe5d4 100644 --- a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp +++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. @@ -40,8 +40,7 @@ LeafInterfaceDBusStubAdapter::LeafInterfaceDBusStubAdapter( const std::shared_ptr& stub): LeafInterfaceDBusStubAdapterHelper(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, std::dynamic_pointer_cast(stub), - NULL) - { + false) { } LeafInterfaceDBusStubAdapter::~LeafInterfaceDBusStubAdapter() { diff --git a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h index f67cc26..8775a83 100644 --- a/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h +++ b/src/test/commonapi/tests/managed/LeafInterfaceDBusStubAdapter.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterface.h b/src/test/commonapi/tests/managed/RootInterface.h index 398e60c..85fff90 100644 --- a/src/test/commonapi/tests/managed/RootInterface.h +++ b/src/test/commonapi/tests/managed/RootInterface.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp index 4d74952..b27e0eb 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp +++ b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h index 5aaf63f..70e9a28 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h +++ b/src/test/commonapi/tests/managed/RootInterfaceDBusProxy.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp index 1a3a6dc..9872b58 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp +++ b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. @@ -40,8 +40,7 @@ RootInterfaceDBusStubAdapter::RootInterfaceDBusStubAdapter( const std::shared_ptr& stub): RootInterfaceDBusStubAdapterHelper(factory, commonApiAddress, dbusInterfaceName, dbusBusName, dbusObjectPath, dbusConnection, std::dynamic_pointer_cast(stub), - new CommonAPI::DBus::DBusObjectManagerStub(dbusObjectPath, dbusConnection)) - { + true) { } RootInterfaceDBusStubAdapter::~RootInterfaceDBusStubAdapter() { @@ -109,9 +108,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubLeafInterface(std::shared_ if (objectPath.compare(0, dbusObjectPath_.length(), dbusObjectPath_) == 0) { auto dbusStubAdapter = factory_->createDBusStubAdapter(stub, "commonapi.tests.managed.LeafInterface", instance, "commonapi.tests.managed.LeafInterface", "local"); - bool ok = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); - if (ok) { - bool isServiceExportSuccessful = managerStub->exportDBusStubAdapter(dbusStubAdapter.get()); + + bool success = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); + if (success) { + bool isServiceExportSuccessful = dbusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter); if (isServiceExportSuccessful) { registeredLeafInterfaceInstances.insert(instance); return true; @@ -129,10 +129,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubLeafInterface(std::shared_ bool RootInterfaceDBusStubAdapter::deregisterManagedStubLeafInterface(const std::string& instance) { std::string commonApiAddress = "local:commonapi.tests.managed.LeafInterface:" + instance; if (registeredLeafInterfaceInstances.find(instance) != registeredLeafInterfaceInstances.end()) { - std::shared_ptr adapter = + std::shared_ptr dbusStubAdapter = CommonAPI::DBus::DBusServicePublisher::getInstance()->getRegisteredService(commonApiAddress); - if (adapter != nullptr) { - managerStub->unexportDBusStubAdapter(adapter.get()); + if (dbusStubAdapter != nullptr) { + dbusConnection_->getDBusObjectManager()->unexportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter); CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress); registeredLeafInterfaceInstances.erase(instance); return true; @@ -162,9 +162,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubBranchInterface(std::share if (objectPath.compare(0, dbusObjectPath_.length(), dbusObjectPath_) == 0) { auto dbusStubAdapter = factory_->createDBusStubAdapter(stub, "commonapi.tests.managed.BranchInterface", instance, "commonapi.tests.managed.BranchInterface", "local"); - bool ok = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); - if (ok) { - bool isServiceExportSuccessful = managerStub->exportDBusStubAdapter(dbusStubAdapter.get()); + + bool success = CommonAPI::DBus::DBusServicePublisher::getInstance()->registerManagedService(dbusStubAdapter); + if (success) { + bool isServiceExportSuccessful = dbusConnection_->getDBusObjectManager()->exportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter); if (isServiceExportSuccessful) { registeredBranchInterfaceInstances.insert(instance); return true; @@ -182,10 +183,10 @@ bool RootInterfaceDBusStubAdapter::registerManagedStubBranchInterface(std::share bool RootInterfaceDBusStubAdapter::deregisterManagedStubBranchInterface(const std::string& instance) { std::string commonApiAddress = "local:commonapi.tests.managed.BranchInterface:" + instance; if (registeredBranchInterfaceInstances.find(instance) != registeredBranchInterfaceInstances.end()) { - std::shared_ptr adapter = + std::shared_ptr dbusStubAdapter = CommonAPI::DBus::DBusServicePublisher::getInstance()->getRegisteredService(commonApiAddress); - if (adapter != nullptr) { - managerStub->unexportDBusStubAdapter(adapter.get()); + if (dbusStubAdapter != nullptr) { + dbusConnection_->getDBusObjectManager()->unexportManagedDBusStubAdapter(dbusObjectPath_, dbusStubAdapter); CommonAPI::DBus::DBusServicePublisher::getInstance()->unregisterManagedService(commonApiAddress); registeredBranchInterfaceInstances.erase(instance); return true; diff --git a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h index a3fd482..c10288d 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h +++ b/src/test/commonapi/tests/managed/RootInterfaceDBusStubAdapter.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceProxy.h b/src/test/commonapi/tests/managed/RootInterfaceProxy.h index 17f570a..741aa05 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceProxy.h +++ b/src/test/commonapi/tests/managed/RootInterfaceProxy.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h b/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h index ca8a693..65380b7 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h +++ b/src/test/commonapi/tests/managed/RootInterfaceProxyBase.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceStub.h b/src/test/commonapi/tests/managed/RootInterfaceStub.h index c0c5da9..2b71e5f 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceStub.h +++ b/src/test/commonapi/tests/managed/RootInterfaceStub.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. diff --git a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp index f4d39d1..6e84512 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp +++ b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.cpp @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. @@ -37,7 +37,7 @@ void RootInterfaceStubDefault::testRootMethod(int32_t inInt, std::string inStrin bool RootInterfaceStubDefault::registerManagedStubLeafInterfaceAutoInstance(std::shared_ptr stub) { autoInstanceCounter_++; std::stringstream ss; - ss << stubAdapter_->getInstanceId() << "." << autoInstanceCounter_; + ss << stubAdapter_->getInstanceId() << ".i" << autoInstanceCounter_; std::string instance = ss.str(); return stubAdapter_->registerManagedStubLeafInterface(stub, instance); } @@ -53,7 +53,7 @@ std::set& RootInterfaceStubDefault::getLeafInterfaceInstances() { bool RootInterfaceStubDefault::registerManagedStubBranchInterfaceAutoInstance(std::shared_ptr stub) { autoInstanceCounter_++; std::stringstream ss; - ss << stubAdapter_->getInstanceId() << "." << autoInstanceCounter_; + ss << stubAdapter_->getInstanceId() << ".i" << autoInstanceCounter_; std::string instance = ss.str(); return stubAdapter_->registerManagedStubBranchInterface(stub, instance); } diff --git a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h index c2e0620..6f3a960 100644 --- a/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h +++ b/src/test/commonapi/tests/managed/RootInterfaceStubDefault.h @@ -1,6 +1,6 @@ /* * This file was generated by the CommonAPI Generators. -* Used org.genivi.commonapi.core 2.1.0.qualifier. +* Used org.genivi.commonapi.core 2.1.3.qualifier. * Used org.franca.core 0.8.9.201308271211. * * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. -- 2.7.4