[4.6.4] Attempt to fix crash in NetworkManager. Part 2

src/framework/cloud/qml/Muse/Cloud/AccountPage.qml

@@ -93,15 +93,15 @@ FocusScope {
         navigationSection: navSec
 
         onSignInRequested: function (cloudCode) {
-            cloudsModel.signIn(cloudCode)
+            Qt.callLater(cloudsModel.signIn, cloudCode)
         }
 
         onSignOutRequested: function (cloudCode) {
-            cloudsModel.signOut(cloudCode)
+            Qt.callLater(cloudsModel.signOut, cloudCode)
         }
 
         onCreateAccountRequested: function (cloudCode) {
-            cloudsModel.createAccount(cloudCode)
+            Qt.callLater(cloudsModel.createAccount, cloudCode)
         }
     }
 }

src/framework/global/types/version.cpp

@@ -60,7 +60,7 @@ static std::array<int, 3> parseVersion(const muse::String& versionString, bool&
     if (componentIdx < result.size()) {
         result.at(componentIdx) = curNum;
     } else {
-        LOGW() << "Ignoring everything after third point";
+        LOGW() << "Ignoring everything after third point: " << versionString;
     }
 
     ok = true;

src/framework/learn/internal/learnservice.cpp

@@ -47,7 +47,7 @@ void LearnService::refreshPlaylists()
 {
     auto startedPlaylistCallBack = [this](const RetVal<Playlist>& result) {
         if (!result.ret) {
-            LOGW() << result.ret.toString();
+            LOGE() << "Unable to get started playlist: " << result.ret.toString();
             return;
         }
 
@@ -65,7 +65,7 @@ void LearnService::refreshPlaylists()
 
     auto advancedPlaylistCallBack = [this](const RetVal<Playlist>& result) {
         if (!result.ret) {
-            LOGW() << result.ret.toString();
+            LOGE() << "Unable to get advanced playlist: " << result.ret.toString();
             return;
         }
 

src/framework/network/internal/networkmanager.cpp

@@ -23,7 +23,6 @@
 
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
-#include <QTimer>
 #include <QEventLoop>
 #include <QUrl>
 
@@ -33,12 +32,11 @@
 using namespace muse;
 using namespace muse::network;
 
-static constexpr int NET_TIMEOUT_MS = 60000;
-
 NetworkManager::NetworkManager(QObject* parent)
     : QObject(parent)
 {
     m_manager = new QNetworkAccessManager(this);
+    m_manager->setTransferTimeout(); // Use Qt's default timeout (30s)
 }
 
 NetworkManager::~NetworkManager()
@@ -81,21 +79,24 @@ Ret NetworkManager::del(const QUrl& url, IncomingDevice* incomingData, const Req
 Ret NetworkManager::execRequest(RequestType requestType, const QUrl& url, IncomingDevice* incomingData, OutgoingDevice* outgoingData,
                                 const RequestHeaders& headers)
 {
-    LOGI() << "Start: " << requestTypeToString(requestType) << ", url: " << url.toString();
+    std::cout << "Start: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
 
     if (outgoingData && outgoingData->device()) {
+        std::cout << "Open outgoing device: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
         if (!openDevice(outgoingData->device(), QIODevice::ReadOnly)) {
             return make_ret(Err::FiledOpenIODeviceRead);
         }
     }
 
     if (incomingData) {
+        std::cout << "Open incoming device: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
         if (!openDevice(incomingData, QIODevice::WriteOnly)) {
             return make_ret(Err::FiledOpenIODeviceWrite);
         }
         m_incomingData = incomingData;
     }
 
+    std::cout << "Prepare headers: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
     QNetworkRequest request(url);
     request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, true);
 
@@ -104,14 +105,15 @@ Ret NetworkManager::execRequest(RequestType requestType, const QUrl& url, Incomi
         _headers = configuration()->defaultHeaders();
     }
 
-    for (QNetworkRequest::KnownHeaders knownHeader: _headers.knownHeaders.keys()) {
-        request.setHeader(knownHeader, _headers.knownHeaders[knownHeader]);
+    for (auto it = _headers.knownHeaders.cbegin(); it != _headers.knownHeaders.cend(); ++it) {
+        request.setHeader(it.key(), it.value());
     }
 
-    for (const QByteArray& rawHeader: _headers.rawHeaders.keys()) {
-        request.setRawHeader(rawHeader, _headers.rawHeaders[rawHeader]);
+    for (auto it = _headers.rawHeaders.cbegin(); it != _headers.rawHeaders.cend(); ++it) {
+        request.setRawHeader(it.key(), it.value());
     }
 
+    std::cout << "Start progress: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
     m_progress.start();
 
     QNetworkReply* reply = receiveReply(requestType, request, outgoingData);
@@ -124,9 +126,11 @@ Ret NetworkManager::execRequest(RequestType requestType, const QUrl& url, Incomi
         prepareReplyReceive(reply, m_incomingData);
     }
 
-    Ret ret = waitForReplyFinished(reply, NET_TIMEOUT_MS);
+    Ret ret = waitForReplyFinished(reply);
     if (!ret) {
-        LOGE() << ret.toString();
+        std::cout << "Error during request: " << requestTypeToString(requestType).toStdString()
+               << ", url: " << url.toString().toStdString()
+               << ", err: " << ret.toString() << "\n";
     }
 
     m_progress.finish(ret);
@@ -136,19 +140,26 @@ Ret NetworkManager::execRequest(RequestType requestType, const QUrl& url, Incomi
     }
 
     if (outgoingData && outgoingData->device()) {
+        std::cout << "Close outgoing device: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
         closeDevice(outgoingData->device());
     }
 
+    if (m_incomingData) {
+        std::cout << "Close incoming device: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
+    }
+
     closeDevice(m_incomingData);
     m_incomingData = nullptr;
 
-    LOGI() << "Finish: " << requestTypeToString(requestType) << ", url: " << url.toString();
+    std::cout << "Finish: " << requestTypeToString(requestType).toStdString() << ", url: " << url.toString().toStdString() << "\n";
 
     return ret;
 }
 
 QNetworkReply* NetworkManager::receiveReply(RequestType requestType, const QNetworkRequest& request, OutgoingDevice* outgoingData)
 {
+    std::cout << "Send request: " << requestTypeToString(requestType).toStdString() << ", url: " << request.url().toString().toStdString() << "\n";
+
     switch (requestType) {
     case GET_REQUEST: return m_manager->get(request);
     case HEAD_REQUEST: return m_manager->head(request);
@@ -179,6 +190,7 @@ QNetworkReply* NetworkManager::receiveReply(RequestType requestType, const QNetw
     }
     }
 
+    UNREACHABLE;
     return nullptr;
 }
 
@@ -193,7 +205,6 @@ void NetworkManager::abort()
         m_reply->abort();
     }
 
-    m_isAborted = true;
     m_progress.finish(make_ret(Err::Abort));
 }
 
@@ -217,14 +228,11 @@ void NetworkManager::closeDevice(QIODevice* device)
     }
 }
 
-bool NetworkManager::isAborted() const
-{
-    return m_isAborted;
-}
-
 void NetworkManager::prepareReplyReceive(QNetworkReply* reply, IncomingDevice* incomingData)
 {
     if (incomingData) {
+        std::cout << "Setup data read: " << reply->url().toString().toStdString() << "\n";
+
         connect(reply, &QNetworkReply::downloadProgress, this, [this](const qint64 curr, const qint64 total) {
             m_progress.progress(curr, total);
         });
@@ -239,54 +247,47 @@ void NetworkManager::prepareReplyReceive(QNetworkReply* reply, IncomingDevice* i
                 return;
             }
 
+            std::cout << "Start read data: " << reply->url().toString().toStdString() << "\n";
             m_incomingData->write(reply->readAll());
+            std::cout << "Finish read data: " << reply->url().toString().toStdString() << "\n";
         });
     }
 }
 
 void NetworkManager::prepareReplyTransmit(QNetworkReply* reply)
 {
-    connect(reply, &QNetworkReply::uploadProgress, [this](const qint64 curr, const qint64 total) {
+    IF_ASSERT_FAILED(reply) {
+        return;
+    }
+
+    std::cout << "Setup progress: " << reply->url().toString().toStdString() << "\n";
+
+    connect(reply, &QNetworkReply::uploadProgress, this, [this](qint64 curr, qint64 total) {
         m_progress.progress(curr, total);
     });
 }
 
-Ret NetworkManager::waitForReplyFinished(QNetworkReply* reply, int timeoutMs)
+Ret NetworkManager::waitForReplyFinished(QNetworkReply* reply)
 {
-    QTimer timeoutTimer;
-    timeoutTimer.setSingleShot(true);
-    m_isAborted = false;
-
-    bool isTimeout = false;
-    connect(&timeoutTimer, &QTimer::timeout, this, [this, &isTimeout]() {
-        isTimeout = true;
-        abort();
-    });
+    IF_ASSERT_FAILED(reply) {
+        return make_ret(Err::UnknownError);
+    }
 
-    auto restartTimeoutTimer = [&timeoutTimer, &isTimeout](qint64, qint64) {
-        if (!isTimeout) {
-            timeoutTimer.start();
-        }
-    };
+    if (reply->isFinished()) {
+        LOGW() << "Reply is not running: " << reply->url().toString();
+        return errorFromReply(reply);
+    }
 
-    connect(reply, &QNetworkReply::downloadProgress, this, restartTimeoutTimer);
-    connect(reply, &QNetworkReply::uploadProgress, this, restartTimeoutTimer);
+    std::cout << "Waiting for reply: " << reply->url().toString().toStdString() << "\n";
 
     QEventLoop loop;
     connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
 
     m_reply = reply;
-    timeoutTimer.start(timeoutMs);
     loop.exec();
     m_reply = nullptr;
 
-    if (isTimeout) {
-        return make_ret(Err::Timeout);
-    }
-
-    if (isAborted()) {
-        return make_ret(Err::Abort);
-    }
+    std::cout << "Reply received: " << reply->url().toString().toStdString() << "\n";
 
     return errorFromReply(reply);
 }
@@ -297,9 +298,15 @@ Ret NetworkManager::errorFromReply(const QNetworkReply* reply) const
         return make_ret(Err::NetworkError);
     }
 
+    LOGI() << "Converting reply to ret: " << reply->url().toString();
+
     Ret ret = muse::make_ok();
 
-    if (reply->error() != QNetworkReply::NoError) {
+    if (reply->error() == QNetworkReply::TimeoutError) {
+        ret = make_ret(Err::Timeout);
+    } else if (reply->error() == QNetworkReply::OperationCanceledError) {
+        ret = make_ret(Err::Abort);
+    } else if (reply->error() != QNetworkReply::NoError) {
         ret.setCode(static_cast<int>(Err::NetworkError));
     }
 

src/framework/network/internal/networkmanager.h

@@ -76,12 +76,10 @@ class NetworkManager : public QObject, public INetworkManager, public Injectable
     bool openDevice(QIODevice* device, QIODevice::OpenModeFlag flags);
     void closeDevice(QIODevice* device);
 
-    bool isAborted() const;
-
     void prepareReplyReceive(QNetworkReply* reply, IncomingDevice* incomingData);
     void prepareReplyTransmit(QNetworkReply* reply);
 
-    Ret waitForReplyFinished(QNetworkReply* reply, int timeoutMs);
+    Ret waitForReplyFinished(QNetworkReply* reply);
     Ret errorFromReply(const QNetworkReply* reply) const;
 
     static String requestTypeToString(RequestType type);
@@ -90,8 +88,6 @@ class NetworkManager : public QObject, public INetworkManager, public Injectable
     IncomingDevice* m_incomingData = nullptr;
     QNetworkReply* m_reply = nullptr;
     Progress m_progress;
-
-    bool m_isAborted = false;
 };
 }
 

src/framework/update/internal/updatescenario.cpp

@@ -71,7 +71,7 @@ muse::async::Promise<Ret> UpdateScenario::checkForUpdate(bool manual)
 
             const bool noUpdate = res.ret.code() == static_cast<int>(Err::NoUpdate);
             if (!noUpdate && !res.ret) {
-                LOGE() << "Unable to check for update, error: " << res.ret.toString();
+                LOGE() << "Unable to check for app update, error: " << res.ret.toString();
                 ret = muse::make_ret(Ret::Code::UnknownError);
 
                 if (manual) {

src/musesounds/internal/musesamplercheckupdatescenario.cpp

@@ -37,6 +37,7 @@ void MuseSamplerCheckUpdateScenario::checkAndShowUpdateIfNeed()
         return;
     }
 
+    LOGI() << "Checking for MuseSampler update...";
     m_alreadyChecked = true;
 
     if (service()->incompatibleLocalVersion()) {
@@ -47,7 +48,7 @@ void MuseSamplerCheckUpdateScenario::checkAndShowUpdateIfNeed()
     auto promise = service()->checkForUpdate();
     promise.onResolve(this, [this](const muse::RetVal<bool>& res) {
         if (!res.ret) {
-            LOGE() << res.ret.toString();
+            LOGE() << "Unable to check for MuseSampler update: " << res.ret.toString();
             return;
         }
 

src/musesounds/internal/musesoundscheckupdatescenario.cpp

@@ -70,7 +70,7 @@ muse::async::Promise<Ret> MuseSoundsCheckUpdateScenario::checkForUpdate(bool man
             };
 
             if (!res.ret) {
-                LOGE() << "Unable to check for update, error: " << res.ret.toString();
+                LOGE() << "Unable to check for MuseSounds update, error: " << res.ret.toString();
                 ret = muse::make_ret(Ret::Code::UnknownError);
                 return;
             }

src/notation/qml/MuseScore/NotationScene/internal/NotationSwitchPanel.qml

@@ -111,7 +111,7 @@ Rectangle {
                 }
 
                 onCloseRequested: {
-                    notationSwitchModel.closeNotation(index)
+                    Qt.callLater(notationSwitchModel.closeNotation, index)
                 }
 
                 onContextMenuItemsRequested: {