C++ DiscoveryQos类代码示例

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

// leadsm to assert failure in GpsInProcessConnector line 185: not yet implemented in connector
TEST_F(End2EndRPCTest, call_rpc_method_and_get_expected_result)
{

    std::shared_ptr<MockGpsProvider> mockProvider(new MockGpsProvider());
    types::Localisation::GpsLocation gpsLocation1(1.1, 2.2, 3.3, types::Localisation::GpsFixEnum::MODE2D, 0.0, 0.0, 0.0, 0.0, 444, 444, 4);

    runtime->registerProvider<vehicle::GpsProvider>(domain, mockProvider);
    QThreadSleep::msleep(550);

    ProxyBuilder<vehicle::GpsProxy>* gpsProxyBuilder = runtime->createProxyBuilder<vehicle::GpsProxy>(domain);
    DiscoveryQos discoveryQos;
    discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
    discoveryQos.setDiscoveryTimeout(1000);

    qlonglong qosRoundTripTTL = 40000;
    QSharedPointer<vehicle::GpsProxy> gpsProxy(gpsProxyBuilder
            ->setMessagingQos(MessagingQos(qosRoundTripTTL))
            ->setCached(false)
            ->setDiscoveryQos(discoveryQos)
            ->build());
    std::shared_ptr<Future<int> >gpsFuture (gpsProxy->calculateAvailableSatellitesAsync());
    gpsFuture->waitForFinished();
    int expectedValue = 42; //as defined in MockGpsProvider
    int actualValue;
    gpsFuture->getValues(actualValue);
    EXPECT_EQ(expectedValue, actualValue);
    //TODO CA: shared pointer for proxy builder?
    delete gpsProxyBuilder;
    // This is not yet implemented in CapabilitiesClient
    // runtime->unregisterProvider("Fake_ParticipantId_vehicle/gpsDummyProvider");
}

TEST_F(End2EndSSLTest, call_rpc_method_and_get_expected_result)
{

    // Create a provider
    std::shared_ptr<MockGpsProvider> mockProvider(new MockGpsProvider());
    runtime->registerProvider<vehicle::GpsProvider>(domain, mockProvider);
    std::this_thread::sleep_for(std::chrono::milliseconds(550));

    // Build a proxy
    ProxyBuilder<vehicle::GpsProxy>* gpsProxyBuilder = runtime->createProxyBuilder<vehicle::GpsProxy>(domain);
    DiscoveryQos discoveryQos;
    discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
    discoveryQos.setDiscoveryTimeout(1000);

    qlonglong qosRoundTripTTL = 40000;
    std::shared_ptr<vehicle::GpsProxy> gpsProxy(gpsProxyBuilder
            ->setMessagingQos(MessagingQos(qosRoundTripTTL))
            ->setCached(false)
            ->setDiscoveryQos(discoveryQos)
            ->build());

    // Call the provider and wait for a result
    std::shared_ptr<Future<int> >gpsFuture (gpsProxy->calculateAvailableSatellitesAsync());
    gpsFuture->wait();

    int expectedValue = 42; //as defined in MockGpsProvider
    int actualValue;
    gpsFuture->get(actualValue);
    EXPECT_EQ(expectedValue, actualValue);
    delete gpsProxyBuilder;
}

TEST_F(LocalCapabilitiesDirectoryTest, registerCapabilityAddsToCache) {
    EXPECT_CALL(*capabilitiesClient, getCapabilitiesForParticipantId(dummyParticipantId1,_)).Times(0);
    EXPECT_CALL(*capabilitiesClient, registerCapabilities(_)).Times(1);
    localCapabilitiesDirectory->registerCapability(DOMAIN_1_NAME ,INTERFACE_1_NAME, types::ProviderQos(), dummyParticipantId1);

    DiscoveryQos qos;
    qos.setCacheMaxAge(LocalCapabilitiesDirectory::NO_CACHE_FRESHNESS_REQ());
    qos.setDiscoveryTimeout(ICapabilities::NO_TIMEOUT());

    localCapabilitiesDirectory->getCapabilities(dummyParticipantId1, callback, discoveryQos);
    EXPECT_EQ(1, callback->getResults(TIMEOUT).size());
}

TEST_F(CapabilitiesClientTest, registerAndRetrieveCapability) {
    CapabilitiesClient* capabilitiesClient = new CapabilitiesClient(channelId);// ownership of this is not transferred
    ProxyBuilder<infrastructure::GlobalCapabilitiesDirectoryProxy>* capabilitiesProxyBuilder =
            runtime->createProxyBuilder<infrastructure::GlobalCapabilitiesDirectoryProxy>(
                TypeUtil::toStd(messagingSettings.getDiscoveryDirectoriesDomain())
            );
    DiscoveryQos discoveryQos;
    discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY); //actually only one provider should be available
    QSharedPointer<infrastructure::GlobalCapabilitiesDirectoryProxy> cabilitiesProxy (
        capabilitiesProxyBuilder
            ->setMessagingQos(MessagingQos(10000)) //TODO magic values.
            ->setCached(true)
            ->setDiscoveryQos(discoveryQos)
            ->build()
        );
    capabilitiesClient->init(cabilitiesProxy);

    std::vector<types::CapabilityInformation> capabilitiesInformationList;
    std::string capDomain("testDomain");
    std::string capInterface("testInterface");
    types::ProviderQos capProviderQos;
    std::string capChannelId("testChannelId");
    std::string capParticipantId("testParticipantId");

    capabilitiesInformationList.push_back(types::CapabilityInformation(capDomain, capInterface, capProviderQos, capChannelId, capParticipantId));
    LOG_DEBUG(logger,"Registering capabilities");
    capabilitiesClient->add(capabilitiesInformationList);
    LOG_DEBUG(logger,"Registered capabilities");
    //sync methods are not yet implemented
//    std::vector<types::QtCapabilityInformation> capResultList = capabilitiesClient->lookup(capDomain, capInterface);
//    EXPECT_EQ(capResultList, capabilitiesInformationList);
    QSharedPointer<GlobalCapabilitiesMock> callback(new GlobalCapabilitiesMock());

    // use a semaphore to wait for capabilities to be received
    QSemaphore semaphore(0);
    EXPECT_CALL(*callback, capabilitiesReceived(A<const std::vector<types::CapabilityInformation>&>()))
           .WillRepeatedly(
                DoAll(
                    ReleaseSemaphore(&semaphore),
                    Return(RequestStatus(RequestStatusCode::OK))
                ));
    std::function<void(const std::vector<types::CapabilityInformation>&)> onSuccess =
            [&](const std::vector<types::CapabilityInformation>& capabilities) {
                callback->capabilitiesReceived(capabilities);
            };

    LOG_DEBUG(logger,"get capabilities");
    capabilitiesClient->lookup(capDomain, capInterface, onSuccess);
    semaphore.tryAcquire(1,10000);
    LOG_DEBUG(logger,"finished get capabilities");

    delete capabilitiesProxyBuilder;
}

TEST_F(End2EndBroadcastTest, subscribeToBroadcastWithEnumOutput) {
    tests::testTypes::TestEnum::Enum expectedTestEnum = tests::testTypes::TestEnum::TWO;
    MockSubscriptionListenerOneType<tests::testTypes::TestEnum::Enum>* mockListener =
            new MockSubscriptionListenerOneType<tests::testTypes::TestEnum::Enum>();

    // Use a semaphore to count and wait on calls to the mock listener
    ON_CALL(*mockListener, onReceive(Eq(expectedTestEnum)))
            .WillByDefault(ReleaseSemaphore(&semaphore));

    std::shared_ptr<ISubscriptionListener<tests::testTypes::TestEnum::Enum>> subscriptionListener(
                    mockListener);

    std::shared_ptr<MyTestProvider> testProvider(new MyTestProvider());
    runtime1->registerProvider<tests::testProvider>(domainName, testProvider);

    //This wait is necessary, because registerProvider is async, and a lookup could occur
    // before the register has finished.
    QThreadSleep::msleep(registerProviderWait);

    ProxyBuilder<tests::testProxy>* testProxyBuilder
            = runtime2->createProxyBuilder<tests::testProxy>(domainName);
    DiscoveryQos discoveryQos;
    discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
    discoveryQos.setDiscoveryTimeout(1000);
    discoveryQos.setRetryInterval(250);

    qlonglong qosRoundTripTTL = 500;

    // Send a message and expect to get a result
    tests::testProxy* testProxy = testProxyBuilder
            ->setMessagingQos(MessagingQos(qosRoundTripTTL))
            ->setCached(false)
            ->setDiscoveryQos(discoveryQos)
            ->build();

    int64_t minInterval_ms = 50;
    OnChangeSubscriptionQos subscriptionQos(
                500000,   // validity_ms
                minInterval_ms);  // minInterval_ms

    testProxy->subscribeToBroadcastWithEnumOutputBroadcast(subscriptionListener, subscriptionQos);

    waitForBroadcastSubscriptionArrivedAtProvider(testProvider, "broadcastWithEnumOutput");

    testProvider->fireBroadcastWithEnumOutput(expectedTestEnum);

    // Wait for a subscription message to arrive
    ASSERT_TRUE(semaphore.tryAcquire(1, 3000));

    delete testProxyBuilder;
    delete testProxy;
}

    void testOneShotAttributeSubscription(const T& expectedValue,
                                          SubscribeTo subscribeTo,
                                          ChangeAttribute setAttribute,
                                          const std::string& attributeName) {
        MockSubscriptionListenerOneType<T>* mockListener =
                new MockSubscriptionListenerOneType<T>();

        // Use a semaphore to count and wait on calls to the mock listener
        ON_CALL(*mockListener, onReceive(Eq(expectedValue)))
                .WillByDefault(ReleaseSemaphore(&semaphore));

        std::shared_ptr<ISubscriptionListener<T>> subscriptionListener(
                        mockListener);

        std::shared_ptr<tests::DefaulttestProvider> testProvider(new tests::DefaulttestProvider());
        runtime1->registerProvider<tests::testProvider>(domainName, testProvider);

        //This wait is necessary, because registerProvider is async, and a lookup could occur
        // before the register has finished.
        std::this_thread::sleep_for(std::chrono::milliseconds(registerProviderWait));

        (*testProvider.*setAttribute)(expectedValue, [](){}, [](const joynr::exceptions::ProviderRuntimeException&) {});
        ProxyBuilder<tests::testProxy>* testProxyBuilder
                = runtime2->createProxyBuilder<tests::testProxy>(domainName);
        DiscoveryQos discoveryQos;
        discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
        discoveryQos.setDiscoveryTimeout(1000);
        discoveryQos.setRetryInterval(250);

        std::int64_t qosRoundTripTTL = 500;

        // Send a message and expect to get a result
        tests::testProxy* testProxy = testProxyBuilder
                ->setMessagingQos(MessagingQos(qosRoundTripTTL))
                ->setCached(false)
                ->setDiscoveryQos(discoveryQos)
                ->build();

        std::int64_t minInterval_ms = 50;
        OnChangeSubscriptionQos subscriptionQos(
                    500000,   // validity_ms
                    minInterval_ms);  // minInterval_ms

        subscribeTo(testProxy, subscriptionListener, subscriptionQos);
        waitForAttributeSubscriptionArrivedAtProvider(testProvider, attributeName);

        // Wait for a subscription message to arrive
        ASSERT_TRUE(semaphore.waitFor(std::chrono::seconds(3)));

        delete testProxyBuilder;
        delete testProxy;
    }

// This test is disabled, because the feature is not yet implemented on the server.
TEST_F(CombinedEnd2EndTest, DISABLED_channelUrlProxyUnRegistersUrlsCorrectly) {
    ProxyBuilder<infrastructure::ChannelUrlDirectoryProxy>* channelUrlDirectoryProxyBuilder =
            runtime1->createProxyBuilder<infrastructure::ChannelUrlDirectoryProxy>(
                messagingSettings1.getDiscoveryDirectoriesDomain()
            );

    DiscoveryQos discoveryQos;
    discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
    infrastructure::ChannelUrlDirectoryProxy* channelUrlDirectoryProxy
            = channelUrlDirectoryProxyBuilder
                ->setMessagingQos(MessagingQos(10000))
                ->setCached(true)
                ->setDiscoveryQos(discoveryQos)
                ->build();

    std::string channelId = "bogus_3";
    types::ChannelUrlInformation channelUrlInformation;
    std::vector<std::string> urls = { "bogusTestUrl_1", "bogusTestUrl_2" };
    channelUrlInformation.setUrls(urls);
    try {
        channelUrlDirectoryProxy->registerChannelUrls(channelId, channelUrlInformation);
    }  catch (exceptions::JoynrException& e) {
        ADD_FAILURE()<< "registerChannelUrls was not successful";
    }

    types::ChannelUrlInformation result;
    try {
        channelUrlDirectoryProxy->getUrlsForChannel(result, channelId);
    } catch (exceptions::JoynrException& e) {
        ADD_FAILURE()<< "getUrlsForChannel was not successful";
    }
    EXPECT_EQ(channelUrlInformation,result);

    try {
        channelUrlDirectoryProxy->unregisterChannelUrls(channelId);
    } catch (exceptions::JoynrException& e) {
        ADD_FAILURE()<< "unregisterChannelUrls was not successful";
    }

    types::ChannelUrlInformation result2;
    try {
        channelUrlDirectoryProxy->getUrlsForChannel(result2, channelId);
        ADD_FAILURE()<< "getUrlsForChannel was successful";
    } catch (exceptions::JoynrException& e) {
    }
    EXPECT_EQ(0,result2.getUrls().size());
}

QList<CapabilityEntry> DbusCapabilitiesAdapter::lookup(
        const QString& participantId,
        const DiscoveryQos& discoveryQos
) {
    dbusSkeletonWrapper->logMethodCall("lookup", "DbusCapabilitiesAdapter");
    QSharedPointer<DummyDbusCapabilitiesFuture> future(new DummyDbusCapabilitiesFuture());
    localCapabilitiesDirectory.getCapabilities(participantId, future, discoveryQos);
    return future->get(discoveryQos.getDiscoveryTimeout());
}

KeywordArbitrator::KeywordArbitrator(const std::string& domain,
                                     const std::string& interfaceName,
                                     joynr::system::IDiscoverySync& discoveryProxy,
                                     const DiscoveryQos& discoveryQos)
        : ProviderArbitrator(domain, interfaceName, discoveryProxy, discoveryQos),
          keyword(discoveryQos.getCustomParameter(DiscoveryQos::KEYWORD_PARAMETER()).getValue()),
          logger(joynr_logging::Logging::getInstance()->getLogger("KArb", "KeywordArbitrator"))
{
}

void DbusCapabilitiesUtil::copyJoynrDiscoveryQosToDbus(const DiscoveryQos& joynrDiscoveryQos, joynr::messaging::types::Types::DiscoveryQos& dbusDiscoveryQos) {
    // copy arbitration strategy
    switch (joynrDiscoveryQos.getArbitrationStrategy()) {
    case DiscoveryQos::ArbitrationStrategy::FIXED_PARTICIPANT:
        dbusDiscoveryQos.arbitrationStrategy = joynr::messaging::types::Types::ArbitrationStrategy::FIXED_CHANNEL;
        break;
    case DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY:
        dbusDiscoveryQos.arbitrationStrategy = joynr::messaging::types::Types::ArbitrationStrategy::HIGHEST_PRIORITY;
        break;
    case DiscoveryQos::ArbitrationStrategy::KEYWORD:
        dbusDiscoveryQos.arbitrationStrategy = joynr::messaging::types::Types::ArbitrationStrategy::KEYWORD;
        break;
    case DiscoveryQos::ArbitrationStrategy::LOCAL_ONLY:
        dbusDiscoveryQos.arbitrationStrategy = joynr::messaging::types::Types::ArbitrationStrategy::LOCAL_ONLY;
        break;
    case DiscoveryQos::ArbitrationStrategy::NOT_SET:
        dbusDiscoveryQos.arbitrationStrategy = joynr::messaging::types::Types::ArbitrationStrategy::NOT_SET;
        break;
    default:
        assert(false);
    }

    switch(joynrDiscoveryQos.getDiscoveryScope()) {
    case DiscoveryQos::DiscoveryScope::GLOBAL_ONLY:
        dbusDiscoveryQos.discoveryScope = joynr::messaging::types::Types::DiscoveryScope::GLOBAL_ONLY;
        break;
    case DiscoveryQos::DiscoveryScope::LOCAL_ONLY:
        dbusDiscoveryQos.discoveryScope = joynr::messaging::types::Types::DiscoveryScope::LOCAL_ONLY;
        break;
    case DiscoveryQos::DiscoveryScope::LOCAL_THEN_GLOBAL:
        dbusDiscoveryQos.discoveryScope = joynr::messaging::types::Types::DiscoveryScope::LOCAL_THEN_GLOBAL;
        break;
    case DiscoveryQos::DiscoveryScope::LOCAL_AND_GLOBAL:
        dbusDiscoveryQos.discoveryScope = joynr::messaging::types::Types::DiscoveryScope::LOCAL_AND_GLOBAL;
        break;
    default:
        assert(false);
    }

    dbusDiscoveryQos.cacheMaxAge = joynrDiscoveryQos.getCacheMaxAge();
    dbusDiscoveryQos.discoveryTimeout = joynrDiscoveryQos.getDiscoveryTimeout();
    dbusDiscoveryQos.providerMustSupportOnChange = joynrDiscoveryQos.getProviderMustSupportOnChange();
    dbusDiscoveryQos.retryInterval = joynrDiscoveryQos.getRetryInterval();

    // copy the custom parameter
    auto parameterMap = joynrDiscoveryQos.getCustomParameters();
    for(auto it = parameterMap.begin(); it != parameterMap.end(); it++) {
        types::CustomParameter parameter = *it;
        // initialize dbus parameter
        joynr::messaging::types::Types::CustomParameter dbusParam;
        dbusParam.name = parameter.getName().toStdString();
        dbusParam.value = parameter.getValue().toStdString();
        // add to the map
        dbusDiscoveryQos.customParameters[dbusParam.name] = dbusParam;
    }
}

    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 init(const std::string& settings)
    {
        ccRuntime =
                JoynrClusterControllerRuntime::create(std::make_unique<joynr::Settings>(settings));

        types::ProviderQos providerQos;
        providerQos.setScope(joynr::types::ProviderScope::LOCAL);

        testProvider = std::make_shared<MockTestProvider>();
        providerParticipantId =
                ccRuntime->registerProvider<tests::testProvider>(domain, testProvider, providerQos);

        // Create a proxy
        auto testProxyBuilder = ccRuntime->createProxyBuilder<tests::testProxy>(domain);
        DiscoveryQos discoveryQos;
        discoveryQos.setDiscoveryScope(types::DiscoveryScope::LOCAL_ONLY);
        discoveryQos.setArbitrationStrategy(DiscoveryQos::ArbitrationStrategy::HIGHEST_PRIORITY);
        discoveryQos.setDiscoveryTimeoutMs(1000);

        testProxy = testProxyBuilder->setMessagingQos(MessagingQos(MESSAGINGQOS_TTL))
                            ->setDiscoveryQos(discoveryQos)
                            ->build();
    }

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

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>(
//.........这里部分代码省略.........