TEST_F(JoynrMessageFactoryTest, createRequest_withContentType) {
JoynrMessage joynrMessage = messageFactory.createRequest(
senderID,
receiverID,
qos,
request
);
EXPECT_QSTREQ(senderID, joynrMessage.getHeaderFrom());
EXPECT_QSTREQ(receiverID, joynrMessage.getHeaderTo());
}
void Dispatcher::handleBroadcastSubscriptionRequestReceived(const JoynrMessage& message)
{
JOYNR_LOG_TRACE(logger, "Starting handleBroadcastSubscriptionRequestReceived");
// Make sure that noone is registering a Caller at the moment, because a racing condition could
// occour.
std::lock_guard<std::mutex> lock(subscriptionHandlingMutex);
assert(publicationManager != nullptr);
std::string receiverId = message.getHeaderTo();
std::shared_ptr<RequestCaller> caller = requestCallerDirectory.lookup(receiverId);
std::string jsonSubscriptionRequest = message.getPayload();
// PublicationManager is responsible for deleting SubscriptionRequests
try {
BroadcastSubscriptionRequest subscriptionRequest =
JsonSerializer::deserialize<BroadcastSubscriptionRequest>(jsonSubscriptionRequest);
if (!caller) {
// 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);
}
} catch (const std::invalid_argument& e) {
JOYNR_LOG_ERROR(
logger,
"Unable to deserialize broadcast subscription request object from: {} - error: {}",
jsonSubscriptionRequest,
e.what());
}
}
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());
}