src/CommonAPI/DBus/DBusFactory.cpp

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