C++ JoynrMessage::getHeaderFrom方法代码示例

void Dispatcher::handleBroadcastSubscriptionRequestReceived(const JoynrMessage& message)
{
    LOG_TRACE(logger, "Starting handleBroadcastSubscriptionRequestReceived");
    // Make sure that noone is registering a Caller at the moment, because a racing condition could
    // occour.
    QMutexLocker locker(&subscriptionHandlingMutex);
    assert(publicationManager != NULL);

    QString receiverId = message.getHeaderTo();
    QSharedPointer<RequestCaller> caller = requestCallerDirectory.lookup(receiverId.toStdString());

    QByteArray jsonSubscriptionRequest = message.getPayload();

    // PublicationManager is responsible for deleting SubscriptionRequests
    BroadcastSubscriptionRequest* subscriptionRequest =
            JsonSerializer::deserialize<BroadcastSubscriptionRequest>(jsonSubscriptionRequest);
    if (subscriptionRequest == Q_NULLPTR) {
        LOG_ERROR(logger,
                  QString("Unable to deserialize broadcast subscription request object from: %1")
                          .arg(QString::fromUtf8(jsonSubscriptionRequest)));
        return;
    }

    if (caller.isNull()) {
        // Provider not registered yet
        // Dispatcher will call publicationManger->restore when a new provider is added to activate
        // subscriptions for that provider
        publicationManager->add(
                message.getHeaderFrom(), message.getHeaderTo(), *subscriptionRequest);
    } else {
        publicationManager->add(message.getHeaderFrom(),
                                message.getHeaderTo(),
                                caller,
                                *subscriptionRequest,
                                messageSender);
    }
    delete subscriptionRequest;
}

void Dispatcher::handleRequestReceived(const JoynrMessage& message)
{
    std::string senderId = message.getHeaderFrom();
    std::string receiverId = message.getHeaderTo();

    // json request
    // lookup necessary data
    std::string jsonRequest = message.getPayload();
    std::shared_ptr<RequestCaller> caller = requestCallerDirectory.lookup(receiverId);
    if (caller == nullptr) {
        JOYNR_LOG_ERROR(
                logger,
                "caller not found in the RequestCallerDirectory for receiverId {}, ignoring",
                receiverId);
        return;
    }
    std::string interfaceName = caller->getInterfaceName();

    // Get the request interpreter that has been registered with this interface name
    std::shared_ptr<IRequestInterpreter> requestInterpreter =
            InterfaceRegistrar::instance().getRequestInterpreter(interfaceName);

    // deserialize json
    try {
        Request request = JsonSerializer::deserialize<Request>(jsonRequest);

        std::string requestReplyId = request.getRequestReplyId();
        JoynrTimePoint requestExpiryDate = message.getHeaderExpiryDate();

        std::function<void(std::vector<Variant>)> onSuccess =
                [requestReplyId, requestExpiryDate, this, senderId, receiverId](
                        std::vector<Variant> returnValueVar) {
            Reply reply;
            reply.setRequestReplyId(requestReplyId);
            reply.setResponse(std::move(returnValueVar));
            // send reply back to the original sender (ie. sender and receiver ids are reversed
            // on
            // purpose)
            JOYNR_LOG_DEBUG(logger,
                            "Got reply from RequestInterpreter for requestReplyId {}",
                            requestReplyId);
            JoynrTimePoint now = std::chrono::time_point_cast<std::chrono::milliseconds>(
                    std::chrono::system_clock::now());
            std::int64_t ttl = std::chrono::duration_cast<std::chrono::milliseconds>(
                                       requestExpiryDate - now).count();
            messageSender->sendReply(receiverId, // receiver of the request is sender of reply
                                     senderId,   // sender of request is receiver of reply
                                     MessagingQos(ttl),
                                     reply);
        };

        std::function<void(const exceptions::JoynrException&)> onError =
                [requestReplyId, requestExpiryDate, this, senderId, receiverId](
                        const exceptions::JoynrException& exception) {
            Reply reply;
            reply.setRequestReplyId(requestReplyId);
            reply.setError(joynr::exceptions::JoynrExceptionUtil::createVariant(exception));
            JOYNR_LOG_DEBUG(logger,
                            "Got error reply from RequestInterpreter for requestReplyId {}",
                            requestReplyId);
            JoynrTimePoint now = std::chrono::time_point_cast<std::chrono::milliseconds>(
                    std::chrono::system_clock::now());
            std::int64_t ttl = std::chrono::duration_cast<std::chrono::milliseconds>(
                                       requestExpiryDate - now).count();
            messageSender->sendReply(receiverId, // receiver of the request is sender of reply
                                     senderId,   // sender of request is receiver of reply
                                     MessagingQos(ttl),
                                     reply);
        };
        // execute request
        requestInterpreter->execute(caller,
                                    request.getMethodName(),
                                    request.getParams(),
                                    request.getParamDatatypes(),
                                    onSuccess,
                                    onError);
    } catch (const std::invalid_argument& e) {
        JOYNR_LOG_ERROR(logger,
                        "Unable to deserialize request object from: {} - error: {}",
                        jsonRequest,
                        e.what());
        return;
    }
}

void Dispatcher::handleRequestReceived(const JoynrMessage& message)
{

    std::string senderId = message.getHeaderFrom().toStdString();
    std::string receiverId = message.getHeaderTo().toStdString();

    // json request
    // lookup necessary data
    QByteArray jsonRequest = message.getPayload();
    QSharedPointer<RequestCaller> caller = requestCallerDirectory.lookup(receiverId);
    if (caller == NULL) {
        LOG_ERROR(logger,
                  "caller not found in the RequestCallerDirectory for receiverId " +
                          QString::fromStdString(receiverId) + ", ignoring");
        return;
    }
    std::string interfaceName = caller->getInterfaceName();

    // Get the request interpreter that has been registered with this interface name
    QSharedPointer<IRequestInterpreter> requestInterpreter =
            InterfaceRegistrar::instance().getRequestInterpreter(interfaceName);

    // deserialize json
    Request* request = JsonSerializer::deserialize<Request>(jsonRequest);
    if (request == Q_NULLPTR) {
        LOG_ERROR(logger,
                  QString("Unable to deserialize request object from: %1")
                          .arg(QString::fromUtf8(jsonRequest)));
        return;
    }

    QString requestReplyId = request->getRequestReplyId();
    qint64 requestExpiryDate = message.getHeaderExpiryDate().toMSecsSinceEpoch();

    std::function<void(const QList<QVariant>&)> callbackFct =
            [requestReplyId, requestExpiryDate, this, senderId, receiverId](
                    const QList<QVariant>& returnValueQVar) {
        Reply reply;
        reply.setRequestReplyId(requestReplyId);
        reply.setResponse(returnValueQVar);
        // send reply back to the original sender (ie. sender and receiver ids are reversed
        // on
        // purpose)
        LOG_DEBUG(logger,
                  QString("Got reply from RequestInterpreter for requestReplyId %1")
                          .arg(requestReplyId));
        qint64 ttl = requestExpiryDate - QDateTime::currentMSecsSinceEpoch();
        messageSender->sendReply(receiverId, // receiver of the request is sender of reply
                                 senderId,   // sender of request is receiver of reply
                                 MessagingQos(ttl),
                                 reply);
    };
    // execute request
    requestInterpreter->execute(caller,
                                request->getMethodName(),
                                request->getParams(),
                                request->getParamDatatypes(),
                                callbackFct);

    delete request;
}

 void checkParticipantIDs(const JoynrMessage& joynrMessage){
     EXPECT_QSTREQ(senderID, joynrMessage.getHeaderFrom());
     EXPECT_QSTREQ(receiverID, joynrMessage.getHeaderTo());
 }