SystemServicesRoutingTest() :
settingsFilename("test-resources/SystemServicesRoutingTest.settings"),
settings(new QSettings(settingsFilename, QSettings::IniFormat)),
routingDomain(),
routingProviderParticipantId(),
runtime(NULL),
mockMessageReceiver(new MockMessageReceiver()),
mockMessageSender(new MockMessageSender()),
discoveryQos(),
routingProxyBuilder(NULL),
routingProxy(NULL)
{
SystemServicesSettings systemSettings(*settings);
systemSettings.printSettings();
routingDomain = TypeUtil::toStd(systemSettings.getDomain());
routingProviderParticipantId = systemSettings.getCcRoutingProviderParticipantId();
discoveryQos.setCacheMaxAge(1000);
discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT);
discoveryQos.addCustomParameter("fixedParticipantId", TypeUtil::toStd(routingProviderParticipantId));
discoveryQos.setDiscoveryTimeout(50);
QString channelId("SystemServicesRoutingTest.ChannelId");
EXPECT_CALL(*(dynamic_cast<MockMessageReceiver*>(mockMessageReceiver)), getReceiveChannelId())
.WillRepeatedly(::testing::ReturnRefOfCopy(channelId));
//runtime can only be created, after MockMessageReceiver has been told to return
//a channelId for getReceiveChannelId.
runtime = new JoynrClusterControllerRuntime(NULL, settings, mockMessageReceiver, mockMessageSender);
// routing provider is normally registered in JoynrClusterControllerRuntime::create
runtime->registerRoutingProvider();
}
void SetUp() {
// start libjoynr runtime
runtime = new LibJoynrDbusRuntime(
new Settings(temporarylibjoynrSettingsFilename)
);
SystemServicesSettings systemSettings(settings);
systemSettings.printSettings();
std::string systemServicesDomain(systemSettings.getDomain());
// setup routing proxy
std::string routingProviderParticipantId(systemSettings.getCcRoutingProviderParticipantId());
routingProxyBuilder = runtime
->createProxyBuilder<joynr::system::RoutingProxy>(systemServicesDomain);
DiscoveryQos discoveryQos;
discoveryQos.setCacheMaxAge(1000);
discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT);
discoveryQos.addCustomParameter("fixedParticipantId", routingProviderParticipantId);
discoveryQos.setDiscoveryTimeout(50);
routingProxy = routingProxyBuilder
->setMessagingQos(MessagingQos(5000))
->setCached(false)
->setDiscoveryQos(discoveryQos)
->build();
EXPECT_TRUE(routingProxy != NULL);
// setup discovery proxy
std::string discoveryProviderParticipantId(systemSettings.getCcDiscoveryProviderParticipantId());
discoveryProxyBuilder = runtime
->createProxyBuilder<joynr::system::DiscoveryProxy>(systemServicesDomain);
discoveryQos = DiscoveryQos();
discoveryQos.setCacheMaxAge(1000);
discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT);
discoveryQos.addCustomParameter("fixedParticipantId", discoveryProviderParticipantId);
discoveryQos.setDiscoveryTimeout(50);
discoveryProxy = discoveryProxyBuilder
->setMessagingQos(MessagingQos(5000))
->setCached(false)
->setDiscoveryQos(discoveryQos)
->build();
EXPECT_TRUE(discoveryProxy != NULL);
mockTestProvider = std::make_shared<MockTestProvider>(mockTestProviderQos);
}
void DbusCapabilitiesUtil::copyDbusDiscoveryQosToJoynr(const joynr::messaging::types::Types::DiscoveryQos& dbusDiscoveryQos, DiscoveryQos& joynrDiscoveryQos) {
// copy arbitration strategy
switch (dbusDiscoveryQos.arbitrationStrategy) {
case joynr::messaging::types::Types::ArbitrationStrategy::FIXED_CHANNEL:
joynrDiscoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT);
break;
case joynr::messaging::types::Types::ArbitrationStrategy::HIGHEST_PRIORITY:
joynrDiscoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
break;
case joynr::messaging::types::Types::ArbitrationStrategy::KEYWORD:
joynrDiscoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::KEYWORD);
break;
case joynr::messaging::types::Types::ArbitrationStrategy::LOCAL_ONLY:
joynrDiscoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::LOCAL_ONLY);
break;
case joynr::messaging::types::Types::ArbitrationStrategy::NOT_SET:
joynrDiscoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::NOT_SET);
break;
default:
assert(false);
}
switch(dbusDiscoveryQos.discoveryScope) {
case joynr::messaging::types::Types::DiscoveryScope::GLOBAL_ONLY:
joynrDiscoveryQos.setDiscoveryScope(DiscoveryQos::DiscoveryScope::GLOBAL_ONLY);
break;
case joynr::messaging::types::Types::DiscoveryScope::LOCAL_ONLY:
joynrDiscoveryQos.setDiscoveryScope(DiscoveryQos::DiscoveryScope::LOCAL_ONLY);
break;
case joynr::messaging::types::Types::DiscoveryScope::LOCAL_THEN_GLOBAL:
joynrDiscoveryQos.setDiscoveryScope(DiscoveryQos::DiscoveryScope::LOCAL_THEN_GLOBAL);
break;
case joynr::messaging::types::Types::DiscoveryScope::LOCAL_AND_GLOBAL:
joynrDiscoveryQos.setDiscoveryScope(DiscoveryQos::DiscoveryScope::LOCAL_AND_GLOBAL);
break;
default:
assert(false);
}
joynrDiscoveryQos.setCacheMaxAge(dbusDiscoveryQos.cacheMaxAge);
joynrDiscoveryQos.setDiscoveryTimeout(dbusDiscoveryQos.discoveryTimeout);
joynrDiscoveryQos.setProviderMustSupportOnChange(dbusDiscoveryQos.providerMustSupportOnChange);
joynrDiscoveryQos.setRetryInterval(dbusDiscoveryQos.retryInterval);
// copy the custom parameters
auto parameterMap = dbusDiscoveryQos.customParameters;
for(auto it = parameterMap.begin(); it != parameterMap.end(); it++) {
joynr::messaging::types::Types::CustomParameter parameter = it->second;
// initialize the joynr parameter
joynrDiscoveryQos.addCustomParameter(QString::fromStdString(parameter.name),
QString::fromStdString(parameter.value));
}
}
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());
}
SystemServicesDiscoveryTest()
: settingsFilename("test-resources/SystemServicesDiscoveryTest.settings"),
settings(std::make_unique<Settings>(settingsFilename)),
discoveryDomain(),
discoveryProviderParticipantId(),
runtime(),
mockMessageReceiverHttp(std::make_shared<MockTransportMessageReceiver>()),
mockMessageReceiverMqtt(std::make_shared<MockTransportMessageReceiver>()),
mockMessageSenderMqtt(std::make_shared<MockTransportMessageSender>()),
discoveryQos(),
discoveryProxyBuilder(nullptr),
discoveryProxy(nullptr),
lastSeenDateMs(-1),
expiryDateMs(-1),
publicKeyId(""),
globalMqttTopic("mqtt_SystemServicesDiscoveryTest.topic"),
globalMqttBrokerUrl("mqtt_SystemServicesDiscoveryTest.brokerUrl"),
mqttGlobalAddress(globalMqttBrokerUrl, globalMqttTopic)
{
SystemServicesSettings systemSettings(*settings);
systemSettings.printSettings();
discoveryDomain = systemSettings.getDomain();
discoveryProviderParticipantId = systemSettings.getCcDiscoveryProviderParticipantId();
discoveryQos.setCacheMaxAgeMs(1000);
discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT);
discoveryQos.addCustomParameter("fixedParticipantId", discoveryProviderParticipantId);
discoveryQos.setDiscoveryTimeoutMs(50);
std::string httpChannelId("http_SystemServicesDiscoveryTest.ChannelId");
std::string httpEndPointUrl("http_SystemServicesRoutingTest.endPointUrl");
using system::RoutingTypes::ChannelAddress;
std::string serializedChannelAddress =
joynr::serializer::serializeToJson(ChannelAddress(httpEndPointUrl, httpChannelId));
std::string serializedMqttAddress =
joynr::serializer::serializeToJson(mqttGlobalAddress);
EXPECT_CALL(*(std::dynamic_pointer_cast<MockTransportMessageReceiver>(
mockMessageReceiverHttp).get()),
getSerializedGlobalClusterControllerAddress())
.WillRepeatedly(Return(serializedChannelAddress));
EXPECT_CALL(
*(std::dynamic_pointer_cast<MockTransportMessageReceiver>(mockMessageReceiverMqtt)),
getSerializedGlobalClusterControllerAddress())
.WillRepeatedly(Return(serializedMqttAddress));
EXPECT_CALL(
*(std::dynamic_pointer_cast<MockTransportMessageReceiver>(mockMessageReceiverMqtt)),
getGlobalClusterControllerAddress())
.WillRepeatedly(ReturnRef(mqttGlobalAddress));
// runtime can only be created, after MockCommunicationManager has been told to return
// a channelId for getReceiveChannelId.
runtime = std::make_shared<JoynrClusterControllerRuntime>(std::move(settings),
nullptr,
nullptr,
mockMessageReceiverHttp,
nullptr,
mockMessageReceiverMqtt,
mockMessageSenderMqtt);
// discovery provider is normally registered in JoynrClusterControllerRuntime::create
runtime->init();
discoveryProxyBuilder =
runtime->createProxyBuilder<joynr::system::DiscoveryProxy>(discoveryDomain);
}
TEST_F(MessageNotificationTest, messageToDisconnectedProviderCausesBroadcast)
{
// 1. register provider
auto testProvider = std::make_shared<tests::DefaulttestProvider>();
joynr::types::ProviderQos providerQos;
providerQos.setScope(joynr::types::ProviderScope::LOCAL);
std::string providerParticipantId =
libjoynrProviderRuntime->registerProvider<tests::testProvider>(
testDomain, testProvider, providerQos);
// 2. create proxy
DiscoveryQos discoveryQos;
discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::LAST_SEEN);
discoveryQos.setDiscoveryScope(joynr::types::DiscoveryScope::LOCAL_ONLY);
MessagingQos messagingQos;
messagingQos.setTtl(5000);
auto testProxyBuilder = libjoynrProxyRuntime->createProxyBuilder<tests::testProxy>(testDomain);
auto testProxy =
testProxyBuilder->setMessagingQos(messagingQos)->setDiscoveryQos(discoveryQos)->build();
Settings settings(settingsPath);
SystemServicesSettings systemSettings(settings);
auto messageNotificationProxyBuilder =
libjoynrProxyRuntime->createProxyBuilder<joynr::system::MessageNotificationProxy>(
systemSettings.getDomain());
DiscoveryQos messagingNotificationDiscoveryQos;
messagingNotificationDiscoveryQos.setArbitrationStrategy(
DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT);
messagingNotificationDiscoveryQos.addCustomParameter(
"fixedParticipantId", systemSettings.getCcMessageNotificationProviderParticipantId());
messagingNotificationDiscoveryQos.setDiscoveryScope(joynr::types::DiscoveryScope::LOCAL_ONLY);
auto messageNotificationProxy = messageNotificationProxyBuilder->setMessagingQos(messagingQos)
->setDiscoveryQos(messagingNotificationDiscoveryQos)
->build();
// 3. subscribe to message notification broadcast
auto mockListener = std::make_shared<MockSubscriptionListener>();
EXPECT_CALL(*mockListener, onSubscribed(_)).Times(1);
EXPECT_CALL(*mockListener, onError(_)).Times(0);
joynr::system::MessageNotificationMessageQueuedForDeliveryBroadcastFilterParameters
filterParameters;
filterParameters.setParticipantId(providerParticipantId);
auto future = messageNotificationProxy->subscribeToMessageQueuedForDeliveryBroadcast(
filterParameters, mockListener, std::make_shared<OnChangeSubscriptionQos>());
std::string subscriptionId;
future->get(subscriptionId);
// 4. disconnect provider runtime
libjoynrProviderRuntime->shutdown();
libjoynrProviderRuntime.reset();
// 5. execute call on proxy while provider is not connected to cluster-controller
auto onSuccess = [](const std::int32_t&) { FAIL(); };
auto onError = [](const joynr::exceptions::JoynrRuntimeException&) {};
EXPECT_CALL(*mockListener, onReceive(Eq(providerParticipantId), _))
.WillOnce(ReleaseSemaphore(&semaphore));
testProxy->addNumbersAsync(1, 2, 3, onSuccess, onError);
// 6. wait for a broadcast message to arrive
ASSERT_TRUE(semaphore.waitFor(std::chrono::seconds(3)));
messageNotificationProxy->unsubscribeFromMessageQueuedForDeliveryBroadcast(subscriptionId);
}