1 /* This Source Code Form is subject to the terms of the Mozilla Public
\r
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
\r
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
\r
11 #include "DBusServiceRegistry.h"
\r
12 #include "DBusInputStream.h"
\r
13 #include "DBusDaemonProxy.h"
\r
14 #include "DBusConnection.h"
\r
15 #include "DBusUtils.h"
\r
18 namespace CommonAPI {
\r
22 DBusServiceRegistry::DBusServiceRegistry(std::shared_ptr<DBusConnection> dbusConnection) :
\r
23 dbusConnection_(dbusConnection),
\r
25 serviceStatusEvent_(std::shared_ptr<DBusServiceRegistry>(this)),
\r
29 readyFuture_ = readyPromise_.get_future();
\r
31 dbusNameOwnerChangedEventSubscription_ =
\r
32 dbusConnection_->getDBusDaemonProxy()->getNameOwnerChangedEvent().subscribe(
\r
33 std::bind(&DBusServiceRegistry::onDBusNameOwnerChangedEvent,
\r
35 std::placeholders::_1,
\r
36 std::placeholders::_2,
\r
37 std::placeholders::_3));
\r
38 std::thread(std::bind(&DBusServiceRegistry::isReadyBlocking, this)).detach();
\r
41 void DBusServiceRegistry::registerAvailabilityListener(const std::string& service, const std::function<void(bool)>& listener) {
\r
42 availabilityCallbackList.insert({service, listener});
\r
46 DBusServiceStatusEvent& DBusServiceRegistry::getServiceStatusEvent() {
\r
47 return serviceStatusEvent_;
\r
50 DBusServiceRegistry::~DBusServiceRegistry() {
\r
51 dbusConnection_->getDBusDaemonProxy()->getNameOwnerChangedEvent().unsubscribe(dbusNameOwnerChangedEventSubscription_);
\r
54 std::future<bool>& DBusServiceRegistry::getReadyFuture() {
\r
55 return readyFuture_;
\r
58 bool DBusServiceRegistry::isReadyBlocking() {
\r
61 auto status = readyFuture_.wait_for(std::chrono::seconds(5));
\r
62 if (checkReady(status)) {
\r
66 readyPromise_.set_value(true);
\r
68 readyMutex_.unlock();
\r
73 bool DBusServiceRegistry::isReady() {
\r
77 std::vector<std::string> DBusServiceRegistry::getAvailableServiceInstances(const std::string& serviceInterfaceName,
\r
78 const std::string& serviceDomainName) {
\r
79 if (!isReadyBlocking()) {
\r
80 return std::vector<std::string>();
\r
83 if (serviceDomainName != "local" || !dbusConnection_->isConnected()) {
\r
84 return std::vector<std::string>();
\r
87 std::vector<std::string> addressesOfKnownServiceInstances;
\r
88 auto knownServiceInstancesIteratorPair = dbusCachedProvidersForInterfaces_.equal_range(serviceInterfaceName);
\r
90 while(knownServiceInstancesIteratorPair.first != knownServiceInstancesIteratorPair.second) {
\r
91 const DBusServiceInstanceId dbusServiceInstanceId = knownServiceInstancesIteratorPair.first->second;
\r
92 addressesOfKnownServiceInstances.push_back(findInstanceIdMapping(dbusServiceInstanceId));
\r
93 ++knownServiceInstancesIteratorPair.first;
\r
96 return addressesOfKnownServiceInstances;
\r
99 void DBusServiceRegistry::onManagedPathsList(const CallStatus& status, DBusObjectToInterfaceDict managedObjects,
\r
100 std::list<std::string>::iterator iter, std::shared_ptr<std::list<std::string>> list) {
\r
102 auto objectPathIterator = managedObjects.begin();
\r
104 while (objectPathIterator != managedObjects.end()) {
\r
105 const std::string& serviceObjPath = objectPathIterator->first;
\r
106 auto interfaceNameIterator = objectPathIterator->second.begin();
\r
108 while (interfaceNameIterator != objectPathIterator->second.end()) {
\r
109 const std::string& interfaceName = interfaceNameIterator->first;
\r
110 dbusCachedProvidersForInterfaces_.insert( { interfaceName, { *iter, serviceObjPath } });
\r
111 ++interfaceNameIterator;
\r
113 ++objectPathIterator;
\r
118 if (list->size() == 0) {
\r
119 readyMutex_.lock();
\r
121 readyPromise_.set_value(true);
\r
124 readyMutex_.unlock();
\r
128 bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& address) {
\r
129 std::vector<std::string> parts = split(address, ':');
\r
130 return isServiceInstanceAlive(parts[2], parts[1], parts[0]);
\r
134 bool DBusServiceRegistry::isServiceInstanceAlive(const std::string& serviceInstanceID,
\r
135 const std::string& serviceInterfaceName,
\r
136 const std::string& serviceDomainName ) {
\r
137 if (!isReadyBlocking()) {
\r
141 if (serviceDomainName != "local" || !dbusConnection_->isConnected()) {
\r
145 DBusServiceInstanceId serviceInstanceId = findInstanceIdMapping(serviceInstanceID);
\r
147 auto knownInstancesForInterfaceIteratorPair = dbusCachedProvidersForInterfaces_.equal_range(serviceInterfaceName);
\r
149 while(knownInstancesForInterfaceIteratorPair.first != knownInstancesForInterfaceIteratorPair.second) {
\r
150 DBusServiceInstanceId knownServiceId = knownInstancesForInterfaceIteratorPair.first->second;
\r
151 if(knownServiceId == serviceInstanceId) {
\r
154 ++knownInstancesForInterfaceIteratorPair.first;
\r
160 void DBusServiceRegistry::getManagedObjects(const std::string& dbusWellKnownBusName) {
\r
161 auto callMessage = DBusMessage::createMethodCall(
\r
162 dbusWellKnownBusName.c_str(),
\r
164 "org.freedesktop.DBus.ObjectManager",
\r
165 "GetManagedObjects",
\r
167 dbusConnection_->sendDBusMessageWithReplyAsync(
\r
169 DBusProxyAsyncCallbackHandler<DBusObjectToInterfaceDict>::create(
\r
171 &DBusServiceRegistry::onManagedPaths,
\r
173 std::placeholders::_1,
\r
174 std::placeholders::_2,
\r
175 dbusWellKnownBusName)), 100);
\r
179 void DBusServiceRegistry::onManagedPaths(const CallStatus& status, DBusObjectToInterfaceDict managedObjects,
\r
180 std::string dbusWellKnownBusName) {
\r
182 auto objectPathIterator = managedObjects.begin();
\r
184 while (objectPathIterator != managedObjects.end()) {
\r
185 const std::string& serviceObjPath = objectPathIterator->first;
\r
186 auto interfaceNameIterator = objectPathIterator->second.begin();
\r
188 while (interfaceNameIterator != objectPathIterator->second.end()) {
\r
189 const std::string& interfaceName = interfaceNameIterator->first;
\r
190 dbusCachedProvidersForInterfaces_.insert( { interfaceName, { dbusWellKnownBusName, serviceObjPath } });
\r
191 updateListeners(dbusWellKnownBusName, serviceObjPath, interfaceName, true);
\r
192 ++interfaceNameIterator;
\r
195 ++objectPathIterator;
\r
199 void DBusServiceRegistry::updateListeners(const std::string& conName, const std::string& objName, const std::string& intName , bool available) {
\r
200 auto found = availabilityCallbackList.equal_range(findCommonAPIAddressForDBusAddress(conName, objName, intName));
\r
201 auto foundIter = found.first;
\r
202 while (foundIter != found.second) {
\r
203 foundIter->second(true);
\r
209 void DBusServiceRegistry::addProvidedServiceInstancesToCache(const std::string& dbusNames) {
\r
210 getManagedObjects(dbusNames);
\r
213 void DBusServiceRegistry::addProvidedServiceInstancesToCache(std::vector<std::string>& dbusNames) {
\r
215 std::shared_ptr<std::list<std::string>> dbusList = std::make_shared<std::list<std::string>>(dbusNames.begin(), dbusNames.end());
\r
217 auto iter = dbusList->begin();
\r
219 while (iter != dbusList->end()) {
\r
221 auto callMessage = DBusMessage::createMethodCall(
\r
224 "org.freedesktop.DBus.ObjectManager",
\r
225 "GetManagedObjects",
\r
227 dbusConnection_->sendDBusMessageWithReplyAsync(
\r
229 DBusProxyAsyncCallbackHandler<DBusObjectToInterfaceDict>::create(
\r
231 &DBusServiceRegistry::onManagedPathsList,
\r
233 std::placeholders::_1,
\r
234 std::placeholders::_2,
\r
242 DBusServiceInstanceId DBusServiceRegistry::findInstanceIdMapping(const std::string& instanceId) const {
\r
243 DBusServiceInstanceId instanceDescriptor;
\r
244 findFallbackInstanceIdMapping(instanceId, instanceDescriptor.first, instanceDescriptor.second);
\r
245 return instanceDescriptor;
\r
248 std::string DBusServiceRegistry::findInstanceIdMapping(const DBusServiceInstanceId& dbusInstanceId) const {
\r
249 return findFallbackInstanceIdMapping(dbusInstanceId.first, dbusInstanceId.second);
\r
252 inline const bool isServiceName(const std::string& name) {
\r
253 return name[0] != ':';
\r
256 void DBusServiceRegistry::onDBusNameOwnerChangedEvent(const std::string& affectedName,
\r
257 const std::string& oldOwner,
\r
258 const std::string& newOwner) {
\r
259 if (isServiceName(affectedName)) {
\r
260 if(!oldOwner.empty()) {
\r
261 removeProvidedServiceInstancesFromCache(affectedName);
\r
264 if (!newOwner.empty()) {
\r
265 addProvidedServiceInstancesToCache(affectedName);
\r
271 void DBusServiceRegistry::removeProvidedServiceInstancesFromCache(const std::string& dbusWellKnownBusName) {
\r
272 auto providersForInterfacesIteratorPair = dbusCachedProvidersForInterfaces_.equal_range(dbusWellKnownBusName);
\r
274 //Iteriere über (interfaceName, (serviceInstanceId))
\r
275 while(providersForInterfacesIteratorPair.first != providersForInterfacesIteratorPair.second) {
\r
277 DBusServiceInstanceId dbusInstanceId = providersForInterfacesIteratorPair.first->second;
\r
278 if(dbusInstanceId.first == dbusWellKnownBusName) {
\r
279 auto toErase = providersForInterfacesIteratorPair.first;
\r
280 ++providersForInterfacesIteratorPair.first;
\r
281 dbusCachedProvidersForInterfaces_.erase(toErase);
\r
284 ++providersForInterfacesIteratorPair.first;
\r
288 void DBusServiceRegistry::onListNames(const CommonAPI::CallStatus& callStatus, std::vector<std::string> existingBusConnections) {
\r
290 if (callStatus == CallStatus::SUCCESS) {
\r
291 std::vector<std::string> dbusLivingServiceBusNames;
\r
292 for (const std::string& connectionName : existingBusConnections) {
\r
293 const bool isWellKnownName = (connectionName[0] != ':');
\r
295 if (isWellKnownName) {
\r
296 dbusLivingServiceBusNames.push_back(connectionName);
\r
299 addProvidedServiceInstancesToCache(dbusLivingServiceBusNames);
\r
303 void DBusServiceRegistry::cacheAllServices() {
\r
304 CommonAPI::CallStatus callStatus;
\r
305 std::vector<std::string> existingBusConnections;
\r
306 dbusConnection_->getDBusDaemonProxy()->listNames(callStatus, existingBusConnections);
\r
307 onListNames(callStatus, existingBusConnections);
\r
312 } // namespace CommonAPI
\r