src/CommonAPI/DBus/DBusFactory.cpp

   1 /* Copyright (C) 2013 BMW Group\r
   2  * Author: Manfred Bathelt (manfred.bathelt@bmw.de)\r
   3  * Author: Juergen Gehring (juergen.gehring@bmw.de)\r
   4  * This Source Code Form is subject to the terms of the Mozilla Public\r
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this\r
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\r
   7 #include "DBusProxy.h"\r
   8 #include "DBusConnection.h"\r
   9 #include "DBusFactory.h"\r
  10 #include "DBusAddressTranslator.h"\r
  11 #include "DBusServiceRegistry.h"\r
  12 #include "DBusUtils.h"\r
  13 \r
  14 #include <algorithm>\r
  15 #include <cassert>\r
  16 #include <sstream>\r
  17 #include <unordered_map>\r
  18 #include <vector>\r
  19 \r
  20 namespace CommonAPI {\r
  21 namespace DBus {\r
  22 \r
  23 std::unordered_map<std::string, DBusProxyFactoryFunction>* registeredProxyFactoryFunctions_;\r
  24 std::unordered_map<std::string, DBusAdapterFactoryFunction>* registeredAdapterFactoryFunctions_;\r
  25 \r
  26 \r
  27 void DBusFactory::registerProxyFactoryMethod(std::string interfaceName, DBusProxyFactoryFunction proxyFactoryMethod) {\r
  28     if(!registeredProxyFactoryFunctions_) {\r
  29         registeredProxyFactoryFunctions_ = new std::unordered_map<std::string, DBusProxyFactoryFunction>();\r
  30     }\r
  31     registeredProxyFactoryFunctions_->insert({interfaceName, proxyFactoryMethod});\r
  32 }\r
  33 \r
  34 void DBusFactory::registerAdapterFactoryMethod(std::string interfaceName, DBusAdapterFactoryFunction adapterFactoryMethod) {\r
  35     if(!registeredAdapterFactoryFunctions_) {\r
  36         registeredAdapterFactoryFunctions_ = new std::unordered_map<std::string, DBusAdapterFactoryFunction>();\r
  37     }\r
  38     registeredAdapterFactoryFunctions_->insert({interfaceName, adapterFactoryMethod});\r
  39 }\r
  40 \r
  41 \r
  42 \r
  43 DBusFactory::DBusFactory(std::shared_ptr<Runtime> runtime, const MiddlewareInfo* middlewareInfo) :\r
  44                 CommonAPI::Factory(runtime, middlewareInfo),\r
  45                 dbusConnection_(CommonAPI::DBus::DBusConnection::getSessionBus()),\r
  46                 acquiredConnectionName_("") {\r
  47     dbusConnection_->connect();\r
  48 }\r
  49 \r
  50 DBusFactory::~DBusFactory() {\r
  51 }\r
  52 \r
  53 \r
  54 std::vector<std::string> DBusFactory::getAvailableServiceInstances(const std::string& serviceName,\r
  55                                                                    const std::string& domainName) {\r
  56     return dbusConnection_->getDBusServiceRegistry()->getAvailableServiceInstances(serviceName, domainName);\r
  57 }\r
  58 \r
  59 \r
  60 bool DBusFactory::isServiceInstanceAlive(const std::string& serviceAddress) {\r
  61     std::vector<std::string> parts = split(serviceAddress, ':');\r
  62     assert(parts[0] == "local");\r
  63 \r
  64     std::string interfaceName;\r
  65     std::string connectionName;\r
  66     std::string objectPath;\r
  67     DBusAddressTranslator::getInstance().searchForDBusAddress(serviceAddress, interfaceName, connectionName, objectPath);\r
  68 \r
  69     return dbusConnection_->getDBusServiceRegistry()->isServiceInstanceAlive(interfaceName, connectionName, objectPath);\r
  70 }\r
  71 \r
  72 \r
  73 bool DBusFactory::isServiceInstanceAlive(const std::string& participantId,\r
  74                                          const std::string& serviceName,\r
  75                                          const std::string& domainName) {\r
  76     std::string serviceAddress = domainName + ":" + serviceName + ":" + participantId;\r
  77     return isServiceInstanceAlive(serviceAddress);\r
  78 }\r
  79 \r
  80 std::shared_ptr<Proxy> DBusFactory::createProxy(const char* interfaceId,\r
  81                                                 const std::string& participantId,\r
  82                                                 const std::string& serviceName,\r
  83                                                 const std::string& domain) {\r
  84     std::string commonApiAddress = domain + ":" + serviceName + ":" + participantId;\r
  85 \r
  86     std::string interfaceName;\r
  87     std::string connectionName;\r
  88     std::string objectPath;\r
  89 \r
  90     DBusAddressTranslator::getInstance().searchForDBusAddress(commonApiAddress, interfaceName, connectionName, objectPath);\r
  91 \r
  92     if(!registeredProxyFactoryFunctions_) {\r
  93         registeredProxyFactoryFunctions_ = new std::unordered_map<std::string, DBusProxyFactoryFunction> {};\r
  94     }\r
  95 \r
  96     for (auto it = registeredProxyFactoryFunctions_->begin(); it != registeredProxyFactoryFunctions_->end(); ++it) {\r
  97         if(it->first == interfaceId) {\r
  98             return (it->second)(commonApiAddress, interfaceName, connectionName, objectPath, dbusConnection_);\r
  99         }\r
 100     }\r
 101 \r
 102     return NULL;\r
 103 }\r
 104 \r
 105 std::shared_ptr<StubAdapter> DBusFactory::createAdapter(std::shared_ptr<StubBase> stubBase,\r
 106                                                         const char* interfaceId,\r
 107                                                         const std::string& participantId,\r
 108                                                         const std::string& serviceName,\r
 109                                                         const std::string& domain) {\r
 110     assert(dbusConnection_->isConnected());\r
 111 \r
 112     std::string commonApiAddress = domain + ":" + serviceName + ":" + participantId;\r
 113 \r
 114     std::string interfaceName;\r
 115     std::string connectionName;\r
 116     std::string objectPath;\r
 117 \r
 118     DBusAddressTranslator::getInstance().searchForDBusAddress(commonApiAddress, interfaceName, connectionName, objectPath);\r
 119 \r
 120     if(acquiredConnectionName_ == "") {\r
 121         dbusConnection_->requestServiceNameAndBlock(connectionName);\r
 122         acquiredConnectionName_ = connectionName;\r
 123     } else if (acquiredConnectionName_ != connectionName) {\r
 124         return NULL;\r
 125     }\r
 126 \r
 127     if(!registeredAdapterFactoryFunctions_) {\r
 128         registeredAdapterFactoryFunctions_ = new std::unordered_map<std::string, DBusAdapterFactoryFunction> {};\r
 129     }\r
 130 \r
 131     for (auto it = registeredAdapterFactoryFunctions_->begin(); it != registeredAdapterFactoryFunctions_->end(); ++it) {\r
 132         if(it->first == interfaceId) {\r
 133             std::shared_ptr<DBusStubAdapter> dbusStubAdapter =  (it->second)(commonApiAddress, interfaceName, connectionName, objectPath, dbusConnection_, stubBase);\r
 134             dbusStubAdapter->init();\r
 135             return dbusStubAdapter;\r
 136         }\r
 137     }\r
 138 \r
 139     return NULL;\r
 140 }\r
 141 \r
 142 \r
 143 } // namespace DBus\r
 144 } // namespace CommonAPI\r