Merge pull request #7475 from birarda/udt-fixes

guard long sleeps in udt::SendQueue

libraries/networking/src/AccountManager.cpp

@@ -81,6 +81,8 @@ AccountManager::AccountManager() :
     
     qRegisterMetaType<QHttpMultiPart*>("QHttpMultiPart*");
 
+    qRegisterMetaType<AccountManagerAuth::Type>();
+
     connect(&_accountInfo, &DataServerAccountInfo::balanceChanged, this, &AccountManager::accountInfoBalanceChanged);
 }
 
@@ -215,12 +217,13 @@ void AccountManager::sendRequest(const QString& path,
     if (thread() != QThread::currentThread()) {
         QMetaObject::invokeMethod(this, "sendRequest",
                                   Q_ARG(const QString&, path),
-                                  Q_ARG(AccountManagerAuth::Type, AccountManagerAuth::Required),
+                                  Q_ARG(AccountManagerAuth::Type, authType),
                                   Q_ARG(QNetworkAccessManager::Operation, operation),
                                   Q_ARG(const JSONCallbackParameters&, callbackParams),
                                   Q_ARG(const QByteArray&, dataByteArray),
                                   Q_ARG(QHttpMultiPart*, dataMultiPart),
                                   Q_ARG(QVariantMap, propertyMap));
+        return;
     }
     
     QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance();

libraries/networking/src/UserActivityLogger.cpp

@@ -58,8 +58,6 @@ void UserActivityLogger::logAction(QString action, QJsonObject details, JSONCall
     
     // if no callbacks specified, call our owns
     if (params.isEmpty()) {
-        params.jsonCallbackReceiver = this;
-        params.jsonCallbackMethod = "requestFinished";
         params.errorCallbackReceiver = this;
         params.errorCallbackMethod = "requestError";
     }
@@ -70,10 +68,6 @@ void UserActivityLogger::logAction(QString action, QJsonObject details, JSONCall
                                params, NULL, multipart);
 }
 
-void UserActivityLogger::requestFinished(QNetworkReply& requestReply) {
-    // qCDebug(networking) << object;
-}
-
 void UserActivityLogger::requestError(QNetworkReply& errorReply) {
     qCDebug(networking) << errorReply.error() << "-" << errorReply.errorString();
 }

libraries/networking/src/UserActivityLogger.h

@@ -39,7 +39,6 @@ public slots:
     void wentTo(QString destinationType, QString destinationName);
     
 private slots:
-    void requestFinished(QNetworkReply& requestReply);
     void requestError(QNetworkReply& errorReply);
     
 private:

libraries/networking/src/udt/SendQueue.cpp

@@ -17,6 +17,7 @@
 
 #include <QtCore/QCoreApplication>
 #include <QtCore/QDateTime>
+#include <QtCore/QJsonObject>
 #include <QtCore/QThread>
 
 #include <LogHandler.h>
@@ -27,6 +28,7 @@
 #include "ControlPacket.h"
 #include "Packet.h"
 #include "PacketList.h"
+#include "../UserActivityLogger.h"
 #include "Socket.h"
 
 using namespace udt;
@@ -328,7 +330,39 @@ void SendQueue::run() {
         nextPacketTimestamp += std::chrono::microseconds(nextPacketDelta);
 
         // sleep as long as we need until next packet send, if we can
-        const auto timeToSleep = duration_cast<microseconds>(nextPacketTimestamp - p_high_resolution_clock::now());
+        auto now = p_high_resolution_clock::now();
+        auto timeToSleep = duration_cast<microseconds>(nextPacketTimestamp - now);
+
+        // we're seeing SendQueues sleep for a long period of time here,
+        // which can lock the NodeList if it's attempting to clear connections
+        // for now we guard this by capping the time this thread and sleep for
+
+        const microseconds MAX_SEND_QUEUE_SLEEP_USECS { 2000000 };
+        if (timeToSleep > MAX_SEND_QUEUE_SLEEP_USECS) {
+            qWarning() << "udt::SendQueue wanted to sleep for" << timeToSleep.count() << "microseconds";
+            qWarning() << "Capping sleep to" << MAX_SEND_QUEUE_SLEEP_USECS.count();
+            qWarning() << "PSP:" << _packetSendPeriod << "NPD:" << nextPacketDelta
+                << "NPT:" << nextPacketTimestamp.time_since_epoch().count()
+                << "NOW:" << now.time_since_epoch().count();
+
+            // alright, we're in a weird state
+            // we want to know why this is happening so we can implement a better fix than this guard
+            // send some details up to the API (if the user allows us) that indicate how we could such a large timeToSleep
+            static const QString SEND_QUEUE_LONG_SLEEP_ACTION = "sendqueue-sleep";
+
+            // setup a json object with the details we want
+            QJsonObject longSleepObject;
+            longSleepObject["timeToSleep"] = qint64(timeToSleep.count());
+            longSleepObject["packetSendPeriod"] = _packetSendPeriod.load();
+            longSleepObject["nextPacketDelta"] = nextPacketDelta;
+            longSleepObject["nextPacketTimestamp"] = qint64(nextPacketTimestamp.time_since_epoch().count());
+            longSleepObject["then"] = qint64(now.time_since_epoch().count());
+
+            // hopefully send this event using the user activity logger
+            UserActivityLogger::getInstance().logAction(SEND_QUEUE_LONG_SLEEP_ACTION, longSleepObject);
+
+            timeToSleep = MAX_SEND_QUEUE_SLEEP_USECS;
+        }
 
         std::this_thread::sleep_for(timeToSleep);
     }