WIP: attempt to restart torrent download

Author: illwieckz

currentversionfetcher.cpp

@@ -53,10 +53,10 @@ void CurrentVersionFetcher::fetchCurrentVersion()
     }
 }
 
-void ComponentVersionFetcher(QJsonObject components, QString name, QString system, QString *version, QString *url)
+void ComponentVersionFetcher(QJsonObject components, QString name, QString system, QString *version, std::vector<QString> *urls)
 {
-    QString mirror;
     QString path;
+    QJsonArray mirrors;
 
     QJsonObject component = components[name].toObject();
 
@@ -70,11 +70,9 @@ void ComponentVersionFetcher(QJsonObject components, QString name, QString syste
             *version = versionValue.toString();
         }
 
-        QJsonArray mirrors = component["mirrors"].toArray();
+        mirrors = component["mirrors"].toArray();
         if (!mirrors.count()) {
             qDebug() << "ComponentVersionFetcher: undefined “mirrors” key for " << name;
-        } else {
-            mirror = mirrors.first().toString();
         }
 
         QJsonObject parcels = component["parcels"].toObject();
@@ -95,33 +93,38 @@ void ComponentVersionFetcher(QJsonObject components, QString name, QString syste
         }
     }
 
-    *url = mirror + path;
-
     qDebug() << "ComponentVersionFetcher: fetched component =" << name;
     qDebug() << "ComponentVersionFetcher: fetched system =" << system;
     qDebug() << "ComponentVersionFetcher: fetched version =" << *version;
-    qDebug() << "ComponentVersionFetcher: fetched mirror =" << mirror;
     qDebug() << "ComponentVersionFetcher: fetched path =" << path;
-    qDebug() << "ComponentVersionFetcher: fetched url =" << *url;
+
+    for (auto m : mirrors)
+    {
+        QString mirror = m.toString();
+        qDebug() << "ComponentVersionFetcher: fetched mirror =" << mirror;
+        QString url = mirror + path;
+        qDebug() << "ComponentVersionFetcher: fetched url =" << url;
+        urls->push_back(url);
+    }
 }
 
 void CurrentVersionFetcher::reply(QNetworkReply* reply)
 {
     QString formatVersion;
     QString updaterVersion;
-    QString updaterUrl;
+    std::vector<QString> updaterUrls;
     QString gameVersion;
-    QString gameUrl;
+    std::vector<QString> gameUrls;
     QString newsVersion;
-    QString newsUrl;
+    std::vector<QString> newsUrls;
 
     if (reply->error() != QNetworkReply::NoError) {
         qDebug() << "CurrentVersionFetcher: network error";
 
         if (versionMirror) {
             fetchCurrentVersion();
         } else {
-            emit onCurrentVersions(updaterVersion, updaterUrl, gameVersion, gameUrl, newsUrl);
+            emit onCurrentVersions(updaterVersion, updaterUrls, gameVersion, gameUrls, "");
         }
         return;
     }
@@ -130,7 +133,7 @@ void CurrentVersionFetcher::reply(QNetworkReply* reply)
     QJsonDocument json = QJsonDocument::fromJson(reply->readAll(), &error);
     if (error.error != QJsonParseError::NoError) {
         qDebug() << "CurrentVersionFetcher: JSON parsing error";
-        emit onCurrentVersions(updaterVersion, updaterUrl, gameVersion, gameUrl, newsUrl);
+        emit onCurrentVersions(updaterVersion, updaterUrls, gameVersion, gameUrls, "");
         return;
     }
 
@@ -140,6 +143,8 @@ void CurrentVersionFetcher::reply(QNetworkReply* reply)
 
     if (formatVersionValue == QJsonValue::Undefined) {
         qDebug() << "ComponentVersionFetcher: missing “version” value in current.json";
+        emit onCurrentVersions(updaterVersion, updaterUrls, gameVersion, gameUrls, "");
+        return;
     } else {
         formatVersion = formatVersionValue.toString();
     }
@@ -148,18 +153,20 @@ void CurrentVersionFetcher::reply(QNetworkReply* reply)
 
     if (componentsValue == QJsonValue::Undefined) {
         qDebug() << "ComponentVersionFetcher: missing “components” array in current.json";
+        emit onCurrentVersions(updaterVersion, updaterUrls, gameVersion, gameUrls, "");
+        return;
     } else {
         qDebug() << "ComponentVersionFetcher: fetched format = " << formatVersion;
 
         QJsonObject components = componentsValue.toObject();
 
-        ComponentVersionFetcher(components, "updater", Sys::updaterSystem(), &updaterVersion, &updaterUrl);
+        ComponentVersionFetcher(components, "updater", Sys::updaterSystem(), &updaterVersion, &updaterUrls);
 
-        ComponentVersionFetcher(components, "game", "all-all", &gameVersion, &gameUrl);
+        ComponentVersionFetcher(components, "game", "all-all", &gameVersion, &gameUrls);
 
-        ComponentVersionFetcher(components, "news", "all-all", &newsVersion, &newsUrl);
+        ComponentVersionFetcher(components, "news", "all-all", &newsVersion, &newsUrls);
     }
 
-    emit onCurrentVersions(updaterVersion, updaterUrl, gameVersion, gameUrl, newsUrl);
+    emit onCurrentVersions(updaterVersion, updaterUrls, gameVersion, gameUrls, newsUrls.at(0));
 }
 

currentversionfetcher.h

@@ -31,7 +31,7 @@ class CurrentVersionFetcher : public QObject
     void fetchCurrentVersion();
 
 signals:
-    void onCurrentVersions(QString updaterVersion, QString updaterUrl, QString gameVersion, QString gameUrl, QString newsUrl);
+    void onCurrentVersions(QString updaterVersion, std::vector<QString> updaterUrls, QString gameVersion, std::vector<QString> gameUrls, QString newsUrl);
 
 private slots:
     void reply(QNetworkReply* reply);

downloadworker.cpp

@@ -143,8 +143,6 @@ std::string DownloadWorker::getAriaIndexOut(size_t index, std::string path)
     return std::to_string(index) + "=" + oldPath.toStdString();
 }
 
-
-
 void DownloadWorker::download()
 {
     auto start = std::chrono::steady_clock::now();

qmldownloader.cpp

@@ -122,7 +122,17 @@ void QmlDownloader::onDownloadEvent(int event)
             break;
 
         case aria2::EVENT_ON_DOWNLOAD_ERROR:
-            emit fatalMessage("Error received while downloading");
+            if (!downloadRestarter_) {
+                emit fatalMessage("Error: downloadRestarter unset");
+            }
+            setState(COMPLETED);
+            setDownloadSpeed(0);
+            setUploadSpeed(0);
+            setCompletedSize(0);
+            stopAria();
+            if (!(this->*downloadRestarter_)()) {
+                emit fatalMessage("Error received while downloading");
+            }
             break;
 
         case aria2::EVENT_ON_DOWNLOAD_PAUSE:
@@ -143,7 +153,7 @@ void QmlDownloader::onDownloadEvent(int event)
     }
 }
 
-void QmlDownloader::startUpdate(const QString& selectedInstallPath)
+void QmlDownloader::setInstallPath(const QString& selectedInstallPath)
 {
     qDebug() << "Selected install path:" << selectedInstallPath;
     if (!Sys::validateInstallPath(selectedInstallPath)) {
@@ -159,26 +169,38 @@ void QmlDownloader::startUpdate(const QString& selectedInstallPath)
             return;
         }
     }
+
     if (!QFileInfo(selectedInstallPath).isWritable()) {
         emit fatalMessage("Install dir not writable. Please select another");
         return;
     }
 
-	QString gameUrl = splashController_.gameUrl();
-    qDebug()  << "Using torrent file:" << gameUrl;
     // Persist the install path only now that download has been initiated and we know the path is good
     emit statusMessage("Installing to " + dir.canonicalPath());
     if (settings_.installPath() != selectedInstallPath) {
         qDebug() << "Clearing installed version because path was changed";
         settings_.setInstalledVersion("");
     }
     settings_.setInstallPath(selectedInstallPath);
+}
+
+bool QmlDownloader::startUpdate()
+{
+    QString gameUrl = splashController_.gameUrl();
+    if (gameUrl.isEmpty()) {
+        return false;
+    }
+
+    qDebug()  << "Using torrent URL:" << gameUrl;
+
+    QDir dir(settings_.installPath());
 
     setState(DOWNLOADING);
     worker_ = new DownloadWorker(ariaLogFilename_);
     worker_->setDownloadDirectory(dir.canonicalPath().toStdString());
     worker_->addTorrent(gameUrl.toStdString());
     worker_->moveToThread(&thread_);
+    setDownloadRestarter(&QmlDownloader::startUpdate);
     connect(&thread_, SIGNAL(finished()), worker_, SLOT(deleteLater()));
     connect(worker_, SIGNAL(onDownloadEvent(int)), this, SLOT(onDownloadEvent(int)));
     connect(worker_, SIGNAL(downloadSpeedChanged(int)), this, SLOT(setDownloadSpeed(int)));
@@ -187,14 +209,17 @@ void QmlDownloader::startUpdate(const QString& selectedInstallPath)
     connect(worker_, SIGNAL(completedSizeChanged(int)), this, SLOT(setCompletedSize(int)));
     connect(&thread_, SIGNAL(started()), worker_, SLOT(download()));
     thread_.start();
+
+    return true;
 }
 
 void QmlDownloader::toggleDownload(QString installPath)
 {
     qDebug() << "QmlDownloader::toggleDownload called";
     if (state() == COMPLETED) return;
     if (!worker_) {
-        startUpdate(installPath);
+        setInstallPath(installPath);
+        startUpdate();
         return;
     }
     QMetaObject::invokeMethod(worker_, "toggle");
@@ -212,14 +237,22 @@ void QmlDownloader::stopAria()
     }
 }
 
-void QmlDownloader::startUpdaterUpdate(QString updaterUrl)
+bool QmlDownloader::startUpdaterUpdate()
 {
+    QString updaterUrl = splashController_.updaterUrl();
+    if (updaterUrl.isEmpty()) {
+        return false;
+    }
+
+    qDebug()  << "Using updater URL:" << updaterUrl;
+
     temp_dir_.reset(new QTemporaryDir());
     worker_ = new DownloadWorker(ariaLogFilename_);
     worker_->setDownloadDirectory(QDir(temp_dir_->path()).canonicalPath().toStdString());
     worker_->setConnectUrl(connectUrl_);
     worker_->addUpdaterUri(updaterUrl.toStdString());
     worker_->moveToThread(&thread_);
+    setDownloadRestarter(&QmlDownloader::startUpdaterUpdate);
     connect(&thread_, SIGNAL(finished()), worker_, SLOT(deleteLater()));
     connect(worker_, SIGNAL(onDownloadEvent(int)), this, SLOT(onDownloadEvent(int)));
     connect(worker_, SIGNAL(downloadSpeedChanged(int)), this, SLOT(setDownloadSpeed(int)));
@@ -228,6 +261,8 @@ void QmlDownloader::startUpdaterUpdate(QString updaterUrl)
     connect(worker_, SIGNAL(completedSizeChanged(int)), this, SLOT(setCompletedSize(int)));
     connect(&thread_, SIGNAL(started()), worker_, SLOT(download()));
     thread_.start();
+
+    return true;
 }
 
 QmlDownloader::DownloadState QmlDownloader::state() const
@@ -240,3 +275,8 @@ void QmlDownloader::setState(DownloadState state)
     state_ = state;
     emit stateChanged(state);
 }
+
+void QmlDownloader::setDownloadRestarter(DownloadRestarter downloadRestarter)
+{
+    downloadRestarter_ = downloadRestarter;
+}

qmldownloader.h

@@ -32,6 +32,7 @@
 #include "splashcontroller.h"
 #include "settings.h"
 
+
 class QmlDownloader : public QObject
 {
     Q_OBJECT
@@ -82,13 +83,17 @@ public slots:
     void onDownloadEvent(int event);
 
     Q_INVOKABLE void toggleDownload(QString installPath);
-    Q_INVOKABLE void startUpdaterUpdate(QString version);
 
 private:
+    using DownloadRestarter = bool (QmlDownloader::*)();
+
     void stopAria();
     void setState(DownloadState state);
+    void setInstallPath(const QString& selectedInstallPath);
     void startDownload(const QUrl& url, const QDir& destination);
-    void startUpdate(const QString& selectedInstallPath);
+    void setDownloadRestarter(DownloadRestarter downloadRestarter);
+    bool startUpdate();
+    bool startUpdaterUpdate();
     void launchGameIfInstalled();
 
     QString ariaLogFilename_;
@@ -102,6 +107,7 @@ public slots:
     std::chrono::seconds eta_;
     int totalSize_;
     int completedSize_;
+	DownloadRestarter downloadRestarter_ = nullptr;
 
     DownloadWorker* worker_;
     DownloadTimeCalculator downloadTime_;

splash.qml

@@ -75,7 +75,7 @@ ApplicationWindow {
         }
 
         function onUpdaterUpdate(version) {
-            downloader.startUpdaterUpdate(updaterUrl);
+            downloader.startUpdaterUpdate();
             updaterUpdateLabel.visible = true;
 
             // Now allow the window to go behind other windows in the z-order.

splashcontroller.cpp

@@ -45,33 +45,49 @@ void SplashController::checkForUpdate()
             return;
     }
 
-    connect(&fetcher_, SIGNAL(onCurrentVersions(QString, QString, QString, QString, QString)),
-            this, SLOT(onCurrentVersions(QString, QString, QString, QString, QString)));
+    connect(&fetcher_, SIGNAL(onCurrentVersions(QString, std::vector<QString>, QString, std::vector<QString>, QString)),
+            this, SLOT(onCurrentVersions(QString, std::vector<QString>, QString, std::vector<QString>, QString)));
 
     fetcher_.fetchCurrentVersion();
 }
 
-QString SplashController::gameUrl() const {
-    return latestGameUrl_;
+QString SplashController::updaterUrl() {
+    if (latestUpdaterUrls_.empty()) {
+        return "";
+    }
+
+    QString url = latestUpdaterUrls_.at(0);
+    latestUpdaterUrls_.erase(latestUpdaterUrls_.begin());
+    return url;
+}
+
+QString SplashController::gameUrl() {
+    if (latestGameUrls_.empty()) {
+        return "";
+    }
+
+    QString url = latestGameUrls_.at(0);
+    latestGameUrls_.erase(latestGameUrls_.begin());
+    return url;
 }
 
 QString SplashController::newsUrl() const {
     return latestNewsUrl_;
 }
 
 // Receives the results of the checkForUpdate request.
-void SplashController::onCurrentVersions(QString updaterVersion, QString updaterUrl, QString gameVersion, QString gameUrl, QString newsUrl)
+void SplashController::onCurrentVersions(QString updaterVersion, std::vector<QString> updaterUrls, QString gameVersion, std::vector<QString> gameUrls, QString newsUrl)
 {
     latestUpdaterVersion_ = updaterVersion;
-    latestUpdaterUrl_ = updaterUrl;
+    latestUpdaterUrls_ = updaterUrls;
     latestGameVersion_ = gameVersion;
-    latestGameUrl_ = gameUrl;
+    latestGameUrls_ = gameUrls;
 	latestNewsUrl_ = newsUrl;
 
     emit newsUrlFetched(newsUrl);
 
     if (relaunchCommand_ == RelaunchCommand::UPDATE_UPDATER && updateUpdaterUrl_.isEmpty()) {
-        updateUpdaterUrl_ = latestUpdaterUrl_;
+        updateUpdaterUrl_ = latestUpdaterUrls_.at(0);
         emit updaterUpdateNeeded();
     }
 }
@@ -131,14 +147,14 @@ void SplashController::autoLaunchOrUpdate()
     // If no relaunch action, detect update needed based on versions.json
     if (!latestUpdaterVersion_.isEmpty() && latestUpdaterVersion_ != updaterAppVersion()) {
         qDebug() << "Updater update to version" << latestUpdaterVersion_ << "required";
-        QString updaterArgs = "--splashms 1 --internalcommand updateupdater --updaterurl " + latestUpdaterUrl_;
+        QString updaterArgs = "--splashms 1 --internalcommand updateupdater --updaterurl " + latestUpdaterUrls_.at(0);
         // Remember the URL if we are doing updater update
         if (!connectUrl_.isEmpty()) {
             updaterArgs += " -- " + connectUrl_;
         }
         switch (Sys::RelaunchElevated(updaterArgs)) {
             case Sys::ElevationResult::UNNEEDED:
-                emit updaterUpdate(latestUpdaterUrl_);
+                emit updaterUpdate(latestUpdaterUrls_.at(0));
                 return;
             case Sys::ElevationResult::RELAUNCHED:
                 QCoreApplication::quit();