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);
}
