void LongPollingMessageReceiver::checkServerTime()
{
std::string timeCheckUrl = bounceProxyUrl.getTimeCheckUrl().toString();
std::shared_ptr<IHttpGetBuilder> timeCheckRequestBuilder(
HttpNetworking::getInstance()->createHttpGetBuilder(timeCheckUrl));
std::shared_ptr<HttpRequest> timeCheckRequest(
timeCheckRequestBuilder->addHeader("Accept", "text/plain")
->withTimeout(settings.bounceProxyTimeout)
->build());
JOYNR_LOG_DEBUG(logger, "CheckServerTime: sending request to Bounce Proxy ({})", timeCheckUrl);
std::chrono::system_clock::time_point localTimeBeforeRequest = std::chrono::system_clock::now();
HttpResult timeCheckResult = timeCheckRequest->execute();
std::chrono::system_clock::time_point localTimeAfterRequest = std::chrono::system_clock::now();
std::uint64_t localTime = (TypeUtil::toMilliseconds(localTimeBeforeRequest) +
TypeUtil::toMilliseconds(localTimeAfterRequest)) /
2;
if (timeCheckResult.getStatusCode() != 200) {
JOYNR_LOG_ERROR(logger,
"CheckServerTime: Bounce Proxy not reached [statusCode={}] [body={}]",
timeCheckResult.getStatusCode(),
QString(timeCheckResult.getBody()).toStdString());
} else {
JOYNR_LOG_TRACE(logger,
"CheckServerTime: reply received [statusCode={}] [body={}]",
timeCheckResult.getStatusCode(),
QString(timeCheckResult.getBody()).toStdString());
std::uint64_t serverTime =
TypeUtil::toStdUInt64(QString(timeCheckResult.getBody()).toLongLong());
auto minMaxTime = std::minmax(serverTime, localTime);
std::uint64_t diff = minMaxTime.second - minMaxTime.first;
JOYNR_LOG_INFO(
logger,
"CheckServerTime [server time={}] [local time={}] [diff={} ms]",
TypeUtil::toDateString(JoynrTimePoint(std::chrono::milliseconds(serverTime))),
TypeUtil::toDateString(JoynrTimePoint(std::chrono::milliseconds(localTime))),
diff);
if (diff > 500) {
JOYNR_LOG_ERROR(logger, "CheckServerTime: time difference to server is {} ms", diff);
}
}
}
void SubscriptionManager::registerSubscription(
const std::string& subscribeToName,
std::shared_ptr<ISubscriptionCallback> subscriptionCaller,
const Variant& qosVariant,
SubscriptionRequest& subscriptionRequest)
{
// Register the subscription
std::string subscriptionId = subscriptionRequest.getSubscriptionId();
JOYNR_LOG_DEBUG(logger, "Subscription registered. ID={}", subscriptionId);
if (subscriptions.contains(subscriptionId)) {
// pre-existing subscription: remove it first from the internal data structure
unregisterSubscription(subscriptionId);
}
std::int64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
subscriptionRequest.setQos(qosVariant);
const SubscriptionQos* qos = subscriptionRequest.getSubscriptionQosPtr();
if (qos->getExpiryDateMs() != SubscriptionQos::NO_EXPIRY_DATE() &&
qos->getExpiryDateMs() < now) {
throw std::invalid_argument("Subscription ExpiryDate " +
std::to_string(qos->getExpiryDateMs()) + " in the past. Now: " +
std::to_string(now));
}
auto subscription = std::make_shared<Subscription>(subscriptionCaller);
subscriptions.insert(subscriptionId, subscription);
{
std::lock_guard<std::recursive_mutex> subscriptionLocker(subscription->mutex);
if (SubscriptionUtil::getAlertInterval(qosVariant) > 0 &&
SubscriptionUtil::getPeriodicPublicationInterval(qosVariant) > 0) {
JOYNR_LOG_DEBUG(logger, "Will notify if updates are missed.");
std::int64_t alertAfterInterval = SubscriptionUtil::getAlertInterval(qosVariant);
JoynrTimePoint expiryDate(std::chrono::milliseconds(qos->getExpiryDateMs()));
if (qos->getExpiryDateMs() == SubscriptionQos::NO_EXPIRY_DATE()) {
expiryDate = JoynrTimePoint(
std::chrono::milliseconds(std::numeric_limits<std::int64_t>::max()));
}
std::int64_t periodicPublicationInterval =
SubscriptionUtil::getPeriodicPublicationInterval(qosVariant);
subscription->missedPublicationRunnableHandle = missedPublicationScheduler->schedule(
new MissedPublicationRunnable(expiryDate,
periodicPublicationInterval,
subscriptionId,
subscription,
*this,
alertAfterInterval),
std::chrono::milliseconds(alertAfterInterval));
} else if (qos->getExpiryDateMs() != SubscriptionQos::NO_EXPIRY_DATE()) {
std::int64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
subscription->subscriptionEndRunnableHandle = missedPublicationScheduler->schedule(
new SubscriptionEndRunnable(subscriptionId, *this),
std::chrono::milliseconds(qos->getExpiryDateMs() - now));
}
}
subscriptionRequest.setSubscriptionId(subscriptionId);
subscriptionRequest.setSubscribeToName(subscribeToName);
}
