void JoynrClusterControllerRuntime::initializeAllDependencies() { /** * libjoynr side skeleton & dispatcher * This needs some preparation of libjoynr and clustercontroller parts. */ messagingSettings.printSettings(); libjoynrSettings.printSettings(); wsSettings.printSettings(); // Initialise security manager std::unique_ptr<IPlatformSecurityManager> securityManager = std::make_unique<DummyPlatformSecurityManager>(); // CAREFUL: the factory creates an old style dispatcher, not the new one! inProcessDispatcher = new InProcessDispatcher(); /* CC */ // create the messaging stub factory auto messagingStubFactory = std::make_shared<MessagingStubFactory>(); #ifdef USE_DBUS_COMMONAPI_COMMUNICATION messagingStubFactory->registerStubFactory(std::make_unique<DbusMessagingStubFactory>()); #endif // USE_DBUS_COMMONAPI_COMMUNICATION messagingStubFactory->registerStubFactory(std::make_unique<InProcessMessagingStubFactory>()); // init message router messageRouter = std::make_shared<MessageRouter>(messagingStubFactory, std::move(securityManager)); importMessageRouterFromFile(); const BrokerUrl brokerUrl = messagingSettings.getBrokerUrl(); assert(brokerUrl.getBrokerChannelsBaseUrl().isValid()); const BrokerUrl bounceProxyUrl = messagingSettings.getBounceProxyUrl(); assert(bounceProxyUrl.getBrokerChannelsBaseUrl().isValid()); // If the BrokerUrl is a mqtt url, MQTT is used instead of HTTP const Url url = brokerUrl.getBrokerChannelsBaseUrl(); std::string brokerProtocol = url.getProtocol(); std::string bounceproxyProtocol = bounceProxyUrl.getBrokerChannelsBaseUrl().getProtocol(); std::transform(brokerProtocol.begin(), brokerProtocol.end(), brokerProtocol.begin(), ::toupper); std::transform(bounceproxyProtocol.begin(), bounceproxyProtocol.end(), bounceproxyProtocol.begin(), ::toupper); if (brokerProtocol == joynr::system::RoutingTypes::MqttProtocol::getLiteral( joynr::system::RoutingTypes::MqttProtocol::Enum::MQTT)) { JOYNR_LOG_INFO(logger, "MQTT-Messaging"); doMqttMessaging = true; } else { JOYNR_LOG_INFO(logger, "HTTP-Messaging"); doHttpMessaging = true; } if (!doHttpMessaging && boost::starts_with(bounceproxyProtocol, "HTTP")) { JOYNR_LOG_INFO(logger, "HTTP-Messaging"); doHttpMessaging = true; } std::string capabilitiesDirectoryChannelId = messagingSettings.getCapabilitiesDirectoryChannelId(); std::string capabilitiesDirectoryParticipantId = messagingSettings.getCapabilitiesDirectoryParticipantId(); // provision global capabilities directory if (boost::starts_with(capabilitiesDirectoryChannelId, "{")) { try { using system::RoutingTypes::MqttAddress; auto globalCapabilitiesDirectoryAddress = std::make_shared<MqttAddress>( JsonSerializer::deserialize<MqttAddress>(capabilitiesDirectoryChannelId)); messageRouter->addProvisionedNextHop( capabilitiesDirectoryParticipantId, globalCapabilitiesDirectoryAddress); } catch (const std::invalid_argument& e) { JOYNR_LOG_FATAL(logger, "could not deserialize MqttAddress from {} - error: {}", capabilitiesDirectoryChannelId, e.what()); } } else { auto globalCapabilitiesDirectoryAddress = std::make_shared<const joynr::system::RoutingTypes::ChannelAddress>( messagingSettings.getCapabilitiesDirectoryUrl() + capabilitiesDirectoryChannelId + "/", capabilitiesDirectoryChannelId); messageRouter->addProvisionedNextHop( capabilitiesDirectoryParticipantId, globalCapabilitiesDirectoryAddress); } // setup CC WebSocket interface auto wsMessagingStubFactory = std::make_unique<WebSocketMessagingStubFactory>(); system::RoutingTypes::WebSocketAddress wsAddress = wsSettings.createClusterControllerMessagingAddress(); wsCcMessagingSkeleton = new WebSocketCcMessagingSkeleton(*messageRouter, *wsMessagingStubFactory, wsAddress); messagingStubFactory->registerStubFactory(std::move(wsMessagingStubFactory)); /* LibJoynr */ assert(messageRouter); joynrMessageSender = new JoynrMessageSender(messageRouter); joynrDispatcher = new Dispatcher(joynrMessageSender); joynrMessageSender->registerDispatcher(joynrDispatcher); /* CC */ // TODO: libjoynrmessagingskeleton now uses the Dispatcher, should it use the // InprocessDispatcher? libJoynrMessagingSkeleton = std::make_shared<InProcessLibJoynrMessagingSkeleton>(joynrDispatcher); // EndpointAddress to messagingStub is transmitted when a provider is registered // messagingStubFactory->registerInProcessMessagingSkeleton(libJoynrMessagingSkeleton); std::string httpSerializedGlobalClusterControllerAddress; std::string mqttSerializedGlobalClusterControllerAddress; /** * ClusterController side HTTP * */ if (doHttpMessaging) { if (!httpMessageReceiver) { JOYNR_LOG_INFO(logger, "The http message receiver supplied is NULL, creating the default " "http MessageReceiver"); httpMessageReceiver = std::make_shared<HttpReceiver>(messagingSettings); assert(httpMessageReceiver != nullptr); httpMessagingSkeleton = std::make_shared<HttpMessagingSkeleton>(*messageRouter); httpMessageReceiver->registerReceiveCallback([&](const std::string& msg) { httpMessagingSkeleton->onTextMessageReceived(msg); }); } httpSerializedGlobalClusterControllerAddress = httpMessageReceiver->getGlobalClusterControllerAddress(); // create http message sender if (!httpMessageSender) { JOYNR_LOG_INFO(logger, "The http message sender supplied is NULL, creating the default " "http MessageSender"); httpMessageSender = std::make_shared<HttpSender>( messagingSettings.getBounceProxyUrl(), std::chrono::milliseconds(messagingSettings.getSendMsgMaxTtl()), std::chrono::milliseconds(messagingSettings.getSendMsgRetryInterval())); } messagingStubFactory->registerStubFactory(std::make_unique<HttpMessagingStubFactory>( httpMessageSender, httpSerializedGlobalClusterControllerAddress)); } /** * ClusterController side MQTT * */ if (doMqttMessaging) { if (!mqttMessageReceiver && !mqttMessageSender) { mosqpp::lib_init(); } if (!mqttMessageReceiver) { JOYNR_LOG_INFO(logger, "The mqtt message receiver supplied is NULL, creating the default " "mqtt MessageReceiver"); mqttMessageReceiver = std::make_shared<MqttReceiver>(messagingSettings); assert(mqttMessageReceiver != nullptr); } if (!mqttMessagingIsRunning) { mqttMessagingSkeleton = std::make_shared<MqttMessagingSkeleton>(*messageRouter); mqttMessageReceiver->registerReceiveCallback([&](const std::string& msg) { mqttMessagingSkeleton->onTextMessageReceived(msg); }); } mqttSerializedGlobalClusterControllerAddress = mqttMessageReceiver->getGlobalClusterControllerAddress(); // create message sender if (!mqttMessageSender) { JOYNR_LOG_INFO(logger, "The mqtt message sender supplied is NULL, creating the default " "mqtt MessageSender"); mqttMessageSender = std::make_shared<MqttSender>(messagingSettings.getBrokerUrl()); mqttMessageSender->registerReceiveQueueStartedCallback( [&](void) { mqttMessageReceiver->waitForReceiveQueueStarted(); }); } messagingStubFactory->registerStubFactory(std::make_unique<MqttMessagingStubFactory>( mqttMessageSender, mqttSerializedGlobalClusterControllerAddress)); } capabilitiesClient = new CapabilitiesClient(); std::string localAddress; if (doMqttMessaging) { localAddress = mqttSerializedGlobalClusterControllerAddress; } else { localAddress = httpSerializedGlobalClusterControllerAddress; } localCapabilitiesDirectory = std::make_shared<LocalCapabilitiesDirectory>( messagingSettings, capabilitiesClient, localAddress, *messageRouter); importPersistedLocalCapabilitiesDirectory(); #ifdef USE_DBUS_COMMONAPI_COMMUNICATION dbusSettings = new DbusSettings(*settings); dbusSettings->printSettings(); // register dbus skeletons for capabilities and messaging interfaces std::string ccMessagingAddress(dbusSettings->createClusterControllerMessagingAddressString()); ccDbusMessageRouterAdapter = new DBusMessageRouterAdapter(*messageRouter, ccMessagingAddress); #endif // USE_DBUS_COMMONAPI_COMMUNICATION /** * libJoynr side * */ publicationManager = new PublicationManager(); subscriptionManager = new SubscriptionManager(); inProcessPublicationSender = new InProcessPublicationSender(subscriptionManager); auto libjoynrMessagingAddress = std::make_shared<InProcessMessagingAddress>(libJoynrMessagingSkeleton); // subscriptionManager = new SubscriptionManager(...) inProcessConnectorFactory = new InProcessConnectorFactory( subscriptionManager, publicationManager, inProcessPublicationSender, dynamic_cast<IRequestCallerDirectory*>(inProcessDispatcher)); joynrMessagingConnectorFactory = new JoynrMessagingConnectorFactory(joynrMessageSender, subscriptionManager); auto connectorFactory = std::make_unique<ConnectorFactory>( inProcessConnectorFactory, joynrMessagingConnectorFactory); proxyFactory = new ProxyFactory(libjoynrMessagingAddress, std::move(connectorFactory), &cache); dispatcherList.push_back(joynrDispatcher); dispatcherList.push_back(inProcessDispatcher); // Set up the persistence file for storing provider participant ids std::string persistenceFilename = libjoynrSettings.getParticipantIdsPersistenceFilename(); participantIdStorage = std::make_shared<ParticipantIdStorage>(persistenceFilename); dispatcherAddress = libjoynrMessagingAddress; discoveryProxy = std::make_unique<LocalDiscoveryAggregator>(systemServicesSettings); requestCallerDirectory = dynamic_cast<IRequestCallerDirectory*>(inProcessDispatcher); std::string discoveryProviderParticipantId( systemServicesSettings.getCcDiscoveryProviderParticipantId()); auto discoveryRequestCaller = std::make_shared<joynr::system::DiscoveryRequestCaller>(localCapabilitiesDirectory); auto discoveryProviderAddress = std::make_shared<InProcessAddress>(discoveryRequestCaller); { using joynr::system::DiscoveryInProcessConnector; auto discoveryInProcessConnector = std::make_unique<DiscoveryInProcessConnector>(subscriptionManager, publicationManager, inProcessPublicationSender, std::string(), // can be ignored discoveryProviderParticipantId, discoveryProviderAddress); discoveryProxy->setDiscoveryProxy(std::move(discoveryInProcessConnector)); } capabilitiesRegistrar = std::make_unique<CapabilitiesRegistrar>( dispatcherList, *discoveryProxy, participantIdStorage, dispatcherAddress, messageRouter, messagingSettings.getDiscoveryEntryExpiryIntervalMs()); joynrDispatcher->registerPublicationManager(publicationManager); joynrDispatcher->registerSubscriptionManager(subscriptionManager); /** * Finish initialising Capabilitiesclient by building a Proxy and passing it */ std::int64_t discoveryMessagesTtl = messagingSettings.getDiscoveryMessagesTtl(); ProxyBuilder<infrastructure::GlobalCapabilitiesDirectoryProxy>* capabilitiesProxyBuilder = createProxyBuilder<infrastructure::GlobalCapabilitiesDirectoryProxy>( messagingSettings.getDiscoveryDirectoriesDomain()); DiscoveryQos discoveryQos(10000); discoveryQos.setArbitrationStrategy( DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY); // actually only one provider // should be available std::shared_ptr<infrastructure::GlobalCapabilitiesDirectoryProxy> capabilitiesProxy( capabilitiesProxyBuilder->setMessagingQos(MessagingQos(discoveryMessagesTtl)) ->setCached(true) ->setDiscoveryQos(discoveryQos) ->build()); ((CapabilitiesClient*)capabilitiesClient)->init(capabilitiesProxy); }
void LibJoynrRuntime::init( std::unique_ptr<IMiddlewareMessagingStubFactory> middlewareMessagingStubFactory, std::shared_ptr<const joynr::system::RoutingTypes::Address> libjoynrMessagingAddress, std::shared_ptr<const joynr::system::RoutingTypes::Address> ccMessagingAddress) { // create messaging stub factory auto messagingStubFactory = std::make_unique<MessagingStubFactory>(); messagingStubFactory->registerStubFactory(std::move(middlewareMessagingStubFactory)); messagingStubFactory->registerStubFactory(std::make_unique<InProcessMessagingStubFactory>()); // create message router messageRouter = std::make_shared<MessageRouter>( std::move(messagingStubFactory), libjoynrMessagingAddress); startLibJoynrMessagingSkeleton(*messageRouter); joynrMessageSender = new JoynrMessageSender(messageRouter); joynrDispatcher = new Dispatcher(joynrMessageSender); joynrMessageSender->registerDispatcher(joynrDispatcher); // create the inprocess skeleton for the dispatcher dispatcherMessagingSkeleton = std::make_shared<InProcessLibJoynrMessagingSkeleton>(joynrDispatcher); dispatcherAddress = std::make_shared<InProcessMessagingAddress>(dispatcherMessagingSkeleton); publicationManager = new PublicationManager(); subscriptionManager = new SubscriptionManager(); inProcessDispatcher = new InProcessDispatcher(); inProcessPublicationSender = new InProcessPublicationSender(subscriptionManager); inProcessConnectorFactory = new InProcessConnectorFactory( subscriptionManager, publicationManager, inProcessPublicationSender, dynamic_cast<IRequestCallerDirectory*>(inProcessDispatcher)); joynrMessagingConnectorFactory = new JoynrMessagingConnectorFactory(joynrMessageSender, subscriptionManager); auto connectorFactory = std::make_unique<ConnectorFactory>( inProcessConnectorFactory, joynrMessagingConnectorFactory); proxyFactory = new ProxyFactory(libjoynrMessagingAddress, std::move(connectorFactory), nullptr); // Set up the persistence file for storing provider participant ids std::string persistenceFilename = libjoynrSettings->getParticipantIdsPersistenceFilename(); participantIdStorage = std::make_shared<ParticipantIdStorage>(persistenceFilename); // initialize the dispatchers std::vector<IDispatcher*> dispatcherList; dispatcherList.push_back(inProcessDispatcher); dispatcherList.push_back(joynrDispatcher); joynrDispatcher->registerPublicationManager(publicationManager); joynrDispatcher->registerSubscriptionManager(subscriptionManager); discoveryProxy = std::make_unique<LocalDiscoveryAggregator>(systemServicesSettings); requestCallerDirectory = dynamic_cast<IRequestCallerDirectory*>(inProcessDispatcher); std::string systemServicesDomain = systemServicesSettings.getDomain(); std::string routingProviderParticipantId = systemServicesSettings.getCcRoutingProviderParticipantId(); DiscoveryQos routingProviderDiscoveryQos; routingProviderDiscoveryQos.setCacheMaxAgeMs(1000); routingProviderDiscoveryQos.setArbitrationStrategy( DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT); routingProviderDiscoveryQos.addCustomParameter( "fixedParticipantId", routingProviderParticipantId); routingProviderDiscoveryQos.setDiscoveryTimeoutMs(50); auto routingProxyBuilder = createProxyBuilder<joynr::system::RoutingProxy>(systemServicesDomain); auto routingProxy = routingProxyBuilder->setMessagingQos(MessagingQos(10000)) ->setCached(false) ->setDiscoveryQos(routingProviderDiscoveryQos) ->build(); messageRouter->setParentRouter(std::unique_ptr<system::RoutingProxy>(routingProxy), ccMessagingAddress, routingProviderParticipantId); delete routingProxyBuilder; // setup discovery std::string discoveryProviderParticipantId = systemServicesSettings.getCcDiscoveryProviderParticipantId(); DiscoveryQos discoveryProviderDiscoveryQos; discoveryProviderDiscoveryQos.setCacheMaxAgeMs(1000); discoveryProviderDiscoveryQos.setArbitrationStrategy( DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT); discoveryProviderDiscoveryQos.addCustomParameter( "fixedParticipantId", discoveryProviderParticipantId); discoveryProviderDiscoveryQos.setDiscoveryTimeoutMs(1000); ProxyBuilder<joynr::system::DiscoveryProxy>* discoveryProxyBuilder = createProxyBuilder<joynr::system::DiscoveryProxy>(systemServicesDomain); joynr::system::IDiscoverySync* proxy = discoveryProxyBuilder->setMessagingQos(MessagingQos(10000)) ->setCached(false) ->setDiscoveryQos(discoveryProviderDiscoveryQos) ->build(); discoveryProxy->setDiscoveryProxy(std::unique_ptr<joynr::system::IDiscoverySync>(proxy)); capabilitiesRegistrar = std::make_unique<CapabilitiesRegistrar>( dispatcherList, *discoveryProxy, participantIdStorage, dispatcherAddress, messageRouter, messagingSettings.getDiscoveryEntryExpiryIntervalMs()); }
void JoynrClusterControllerRuntime::initializeAllDependencies() { /** * libjoynr side skeleton & dispatcher * This needs some preparation of libjoynr and clustercontroller parts. */ messagingSettings = new MessagingSettings(*settings); messagingSettings->printSettings(); libjoynrSettings = new LibjoynrSettings(*settings); libjoynrSettings->printSettings(); wsSettings.printSettings(); // Initialise security manager securityManager = new DummyPlatformSecurityManager(); // CAREFUL: the factory creates an old style dispatcher, not the new one! inProcessDispatcher = new InProcessDispatcher(); /* CC */ // create the messaging stub factory MessagingStubFactory* messagingStubFactory = new MessagingStubFactory(); #ifdef USE_DBUS_COMMONAPI_COMMUNICATION messagingStubFactory->registerStubFactory(new DbusMessagingStubFactory()); #endif // USE_DBUS_COMMONAPI_COMMUNICATION messagingStubFactory->registerStubFactory(new InProcessMessagingStubFactory()); // init message router messageRouter = std::shared_ptr<MessageRouter>( new MessageRouter(messagingStubFactory, securityManager)); // provision global capabilities directory std::shared_ptr<joynr::system::RoutingTypes::Address> globalCapabilitiesDirectoryAddress( new system::RoutingTypes::ChannelAddress( messagingSettings->getCapabilitiesDirectoryChannelId())); messageRouter->addProvisionedNextHop(messagingSettings->getCapabilitiesDirectoryParticipantId(), globalCapabilitiesDirectoryAddress); // provision channel url directory std::shared_ptr<joynr::system::RoutingTypes::Address> globalChannelUrlDirectoryAddress( new system::RoutingTypes::ChannelAddress( messagingSettings->getChannelUrlDirectoryChannelId())); messageRouter->addProvisionedNextHop(messagingSettings->getChannelUrlDirectoryParticipantId(), globalChannelUrlDirectoryAddress); // setup CC WebSocket interface WebSocketMessagingStubFactory* wsMessagingStubFactory = new WebSocketMessagingStubFactory(); messagingStubFactory->registerStubFactory(wsMessagingStubFactory); system::RoutingTypes::WebSocketAddress wsAddress = wsSettings.createClusterControllerMessagingAddress(); wsCcMessagingSkeleton = new WebSocketCcMessagingSkeleton(*messageRouter, *wsMessagingStubFactory, wsAddress); /* LibJoynr */ assert(messageRouter); joynrMessageSender = new JoynrMessageSender(messageRouter); joynrDispatcher = new Dispatcher(joynrMessageSender); joynrMessageSender->registerDispatcher(joynrDispatcher); /* CC */ // TODO: libjoynrmessagingskeleton now uses the Dispatcher, should it use the // InprocessDispatcher? libJoynrMessagingSkeleton = std::shared_ptr<InProcessMessagingSkeleton>( new InProcessLibJoynrMessagingSkeleton(joynrDispatcher)); // EndpointAddress to messagingStub is transmitted when a provider is registered // messagingStubFactory->registerInProcessMessagingSkeleton(libJoynrMessagingSkeleton); /** * ClusterController side * */ if (!messageReceiver) { JOYNR_LOG_INFO( logger, "The message receiver supplied is NULL, creating the default MessageReceiver"); messageReceiver = std::shared_ptr<IMessageReceiver>( new HttpReceiver(*messagingSettings, messageRouter)); } std::string channelId = messageReceiver->getReceiveChannelId(); // create message sender if (!messageSender) { JOYNR_LOG_INFO( logger, "The message sender supplied is NULL, creating the default MessageSender"); messageSender = std::shared_ptr<IMessageSender>(new HttpSender( messagingSettings->getBounceProxyUrl(), std::chrono::milliseconds(messagingSettings->getSendMsgMaxTtl()), std::chrono::milliseconds(messagingSettings->getSendMsgRetryInterval()))); } messagingStubFactory->registerStubFactory( new JoynrMessagingStubFactory(messageSender, messageReceiver->getReceiveChannelId())); // joynrMessagingSendSkeleton = new DummyClusterControllerMessagingSkeleton(messageRouter); // ccDispatcher = DispatcherFactory::createDispatcherInSameThread(messagingSettings); // we currently have to use the fake client, because JAVA side is not yet working for // CapabilitiesServer. bool usingRealCapabilitiesClient = /*when switching this to true, turn on the UUID in systemintegrationtests again*/ true; capabilitiesClient = new CapabilitiesClient(channelId); // ownership of this is not transferred // try using the real capabilitiesClient again: // capabilitiesClient = new CapabilitiesClient(channelId);// ownership of this is not // transferred localCapabilitiesDirectory = std::make_shared<LocalCapabilitiesDirectory>( *messagingSettings, capabilitiesClient, *messageRouter); #ifdef USE_DBUS_COMMONAPI_COMMUNICATION dbusSettings = new DbusSettings(*settings); dbusSettings->printSettings(); // register dbus skeletons for capabilities and messaging interfaces std::string ccMessagingAddress(dbusSettings->createClusterControllerMessagingAddressString()); ccDbusMessageRouterAdapter = new DBusMessageRouterAdapter(*messageRouter, ccMessagingAddress); #endif // USE_DBUS_COMMONAPI_COMMUNICATION /** * libJoynr side * */ publicationManager = new PublicationManager(); subscriptionManager = new SubscriptionManager(); inProcessPublicationSender = new InProcessPublicationSender(subscriptionManager); std::shared_ptr<joynr::system::RoutingTypes::Address> libjoynrMessagingAddress( new InProcessMessagingAddress(libJoynrMessagingSkeleton)); // subscriptionManager = new SubscriptionManager(...) inProcessConnectorFactory = new InProcessConnectorFactory( subscriptionManager, publicationManager, inProcessPublicationSender, dynamic_cast<IRequestCallerDirectory*>(inProcessDispatcher)); joynrMessagingConnectorFactory = new JoynrMessagingConnectorFactory(joynrMessageSender, subscriptionManager); connectorFactory = createConnectorFactory(inProcessConnectorFactory, joynrMessagingConnectorFactory); proxyFactory = new ProxyFactory(libjoynrMessagingAddress, connectorFactory, &cache); dispatcherList.push_back(joynrDispatcher); dispatcherList.push_back(inProcessDispatcher); // Set up the persistence file for storing provider participant ids std::string persistenceFilename = libjoynrSettings->getParticipantIdsPersistenceFilename(); participantIdStorage = std::shared_ptr<ParticipantIdStorage>(new ParticipantIdStorage(persistenceFilename)); dispatcherAddress = libjoynrMessagingAddress; discoveryProxy = new LocalDiscoveryAggregator( *dynamic_cast<IRequestCallerDirectory*>(inProcessDispatcher), systemServicesSettings); std::string discoveryProviderParticipantId( systemServicesSettings.getCcDiscoveryProviderParticipantId()); std::shared_ptr<RequestCaller> discoveryRequestCaller( new joynr::system::DiscoveryRequestCaller(localCapabilitiesDirectory)); std::shared_ptr<InProcessAddress> discoveryProviderAddress( new InProcessAddress(discoveryRequestCaller)); joynr::system::DiscoveryInProcessConnector* discoveryInProcessConnector = InProcessConnectorFactoryHelper<joynr::system::IDiscoveryConnector>().create( subscriptionManager, publicationManager, inProcessPublicationSender, std::string(), // can be ignored discoveryProviderParticipantId, discoveryProviderAddress); discoveryProxy->setDiscoveryProxy(discoveryInProcessConnector); capabilitiesRegistrar = new CapabilitiesRegistrar(dispatcherList, *discoveryProxy, libjoynrMessagingAddress, participantIdStorage, dispatcherAddress, messageRouter); joynrDispatcher->registerPublicationManager(publicationManager); joynrDispatcher->registerSubscriptionManager(subscriptionManager); /** * Finish initialising Capabilitiesclient by building a Proxy and passing it */ std::int64_t discoveryMessagesTtl = messagingSettings->getDiscoveryMessagesTtl(); if (usingRealCapabilitiesClient) { ProxyBuilder<infrastructure::GlobalCapabilitiesDirectoryProxy>* capabilitiesProxyBuilder = createProxyBuilder<infrastructure::GlobalCapabilitiesDirectoryProxy>( messagingSettings->getDiscoveryDirectoriesDomain()); DiscoveryQos discoveryQos(10000); discoveryQos.setArbitrationStrategy( DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY); // actually only one provider // should be available std::shared_ptr<infrastructure::GlobalCapabilitiesDirectoryProxy> capabilitiesProxy( capabilitiesProxyBuilder->setMessagingQos(MessagingQos(discoveryMessagesTtl)) ->setCached(true) ->setDiscoveryQos(discoveryQos) ->build()); ((CapabilitiesClient*)capabilitiesClient)->init(capabilitiesProxy); } ProxyBuilder<infrastructure::ChannelUrlDirectoryProxy>* channelUrlDirectoryProxyBuilder = createProxyBuilder<infrastructure::ChannelUrlDirectoryProxy>( messagingSettings->getDiscoveryDirectoriesDomain()); DiscoveryQos discoveryQos(10000); discoveryQos.setArbitrationStrategy( DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY); // actually only one provider // should be available channelUrlDirectoryProxy = std::shared_ptr<infrastructure::ChannelUrlDirectoryProxy>( channelUrlDirectoryProxyBuilder->setMessagingQos(MessagingQos(discoveryMessagesTtl)) ->setCached(true) ->setDiscoveryQos(discoveryQos) ->build()); channelUrlDirectory = std::shared_ptr<ILocalChannelUrlDirectory>( new LocalChannelUrlDirectory(*messagingSettings, channelUrlDirectoryProxy)); messageReceiver->init(channelUrlDirectory); messageSender->init(channelUrlDirectory, *messagingSettings); }