NOISSUE Flatten gui and logic libraries into MultiMC

launcher/modplatform/legacy_ftb/PackFetchTask.cpp

@@ -0,0 +1,172 @@
+#include "PackFetchTask.h"
+#include "PrivatePackManager.h"
+
+#include <QDomDocument>
+#include <BuildConfig.h>
+
+namespace LegacyFTB {
+
+void PackFetchTask::fetch()
+{
+    publicPacks.clear();
+    thirdPartyPacks.clear();
+
+    NetJob *netJob = new NetJob("LegacyFTB::ModpackFetch");
+
+    QUrl publicPacksUrl = QUrl(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/modpacks.xml");
+    qDebug() << "Downloading public version info from" << publicPacksUrl.toString();
+    netJob->addNetAction(Net::Download::makeByteArray(publicPacksUrl, &publicModpacksXmlFileData));
+
+    QUrl thirdPartyUrl = QUrl(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/thirdparty.xml");
+    qDebug() << "Downloading thirdparty version info from" << thirdPartyUrl.toString();
+    netJob->addNetAction(Net::Download::makeByteArray(thirdPartyUrl, &thirdPartyModpacksXmlFileData));
+
+    QObject::connect(netJob, &NetJob::succeeded, this, &PackFetchTask::fileDownloadFinished);
+    QObject::connect(netJob, &NetJob::failed, this, &PackFetchTask::fileDownloadFailed);
+
+    jobPtr.reset(netJob);
+    netJob->start();
+}
+
+void PackFetchTask::fetchPrivate(const QStringList & toFetch)
+{
+    QString privatePackBaseUrl = BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/%1.xml";
+
+    for (auto &packCode: toFetch)
+    {
+        QByteArray *data = new QByteArray();
+        NetJob *job = new NetJob("Fetching private pack");
+        job->addNetAction(Net::Download::makeByteArray(privatePackBaseUrl.arg(packCode), data));
+
+        QObject::connect(job, &NetJob::succeeded, this, [this, job, data, packCode]
+        {
+            ModpackList packs;
+            parseAndAddPacks(*data, PackType::Private, packs);
+            foreach(Modpack currentPack, packs)
+            {
+                currentPack.packCode = packCode;
+                emit privateFileDownloadFinished(currentPack);
+            }
+
+            job->deleteLater();
+
+            data->clear();
+            delete data;
+        });
+
+        QObject::connect(job, &NetJob::failed, this, [this, job, packCode, data](QString reason)
+        {
+            emit privateFileDownloadFailed(reason, packCode);
+            job->deleteLater();
+
+            data->clear();
+            delete data;
+        });
+
+        job->start();
+    }
+}
+
+void PackFetchTask::fileDownloadFinished()
+{
+    jobPtr.reset();
+
+    QStringList failedLists;
+
+    if(!parseAndAddPacks(publicModpacksXmlFileData, PackType::Public, publicPacks))
+    {
+        failedLists.append(tr("Public Packs"));
+    }
+
+    if(!parseAndAddPacks(thirdPartyModpacksXmlFileData, PackType::ThirdParty, thirdPartyPacks))
+    {
+        failedLists.append(tr("Third Party Packs"));
+    }
+
+    if(failedLists.size() > 0)
+    {
+        emit failed(tr("Failed to download some pack lists: %1").arg(failedLists.join("\n- ")));
+    }
+    else
+    {
+        emit finished(publicPacks, thirdPartyPacks);
+    }
+}
+
+bool PackFetchTask::parseAndAddPacks(QByteArray &data, PackType packType, ModpackList &list)
+{
+    QDomDocument doc;
+
+    QString errorMsg = "Unknown error.";
+    int errorLine = -1;
+    int errorCol = -1;
+
+    if(!doc.setContent(data, false, &errorMsg, &errorLine, &errorCol))
+    {
+        auto fullErrMsg = QString("Failed to fetch modpack data: %1 %2:3d!").arg(errorMsg, errorLine, errorCol);
+        qWarning() << fullErrMsg;
+        data.clear();
+        return false;
+    }
+
+    QDomNodeList nodes = doc.elementsByTagName("modpack");
+    for(int i = 0; i < nodes.length(); i++)
+    {
+        QDomElement element = nodes.at(i).toElement();
+
+        Modpack modpack;
+        modpack.name = element.attribute("name");
+        modpack.currentVersion = element.attribute("version");
+        modpack.mcVersion = element.attribute("mcVersion");
+        modpack.description = element.attribute("description");
+        modpack.mods = element.attribute("mods");
+        modpack.logo = element.attribute("logo");
+        modpack.oldVersions = element.attribute("oldVersions").split(";");
+        modpack.broken = false;
+        modpack.bugged = false;
+
+        //remove empty if the xml is bugged
+        for(QString curr : modpack.oldVersions)
+        {
+            if(curr.isNull() || curr.isEmpty())
+            {
+                modpack.oldVersions.removeAll(curr);
+                modpack.bugged = true;
+                qWarning() << "Removed some empty versions from" << modpack.name;
+            }
+        }
+
+        if(modpack.oldVersions.size() < 1)
+        {
+            if(!modpack.currentVersion.isNull() && !modpack.currentVersion.isEmpty())
+            {
+                modpack.oldVersions.append(modpack.currentVersion);
+                qWarning() << "Added current version to oldVersions because oldVersions was empty! (" + modpack.name + ")";
+            }
+            else
+            {
+                modpack.broken = true;
+                qWarning() << "Broken pack:" << modpack.name << " => No valid version!";
+            }
+        }
+
+        modpack.author = element.attribute("author");
+
+        modpack.dir = element.attribute("dir");
+        modpack.file = element.attribute("url");
+
+        modpack.type = packType;
+
+        list.append(modpack);
+    }
+
+    return true;
+}
+
+void PackFetchTask::fileDownloadFailed(QString reason)
+{
+    qWarning() << "Fetching FTBPacks failed:" << reason;
+    emit failed(reason);
+}
+
+}

launcher/modplatform/legacy_ftb/PackFetchTask.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "net/NetJob.h"
+#include <QTemporaryDir>
+#include <QByteArray>
+#include <QObject>
+#include "PackHelpers.h"
+
+namespace LegacyFTB {
+
+class PackFetchTask : public QObject {
+
+    Q_OBJECT
+
+public:
+    PackFetchTask() = default;
+    virtual ~PackFetchTask() = default;
+
+    void fetch();
+    void fetchPrivate(const QStringList &toFetch);
+
+private:
+    NetJobPtr jobPtr;
+
+    QByteArray publicModpacksXmlFileData;
+    QByteArray thirdPartyModpacksXmlFileData;
+
+    bool parseAndAddPacks(QByteArray &data, PackType packType, ModpackList &list);
+    ModpackList publicPacks;
+    ModpackList thirdPartyPacks;
+
+protected slots:
+    void fileDownloadFinished();
+    void fileDownloadFailed(QString reason);
+
+signals:
+    void finished(ModpackList publicPacks, ModpackList thirdPartyPacks);
+    void failed(QString reason);
+
+    void privateFileDownloadFinished(Modpack modpack);
+    void privateFileDownloadFailed(QString reason, QString packCode);
+};
+
+}

launcher/modplatform/legacy_ftb/PackHelpers.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <QList>
+#include <QString>
+#include <QStringList>
+#include <QMetaType>
+
+namespace LegacyFTB {
+
+//Header for structs etc...
+enum class PackType
+{
+    Public,
+    ThirdParty,
+    Private
+};
+
+struct Modpack
+{
+    QString name;
+    QString description;
+    QString author;
+    QStringList oldVersions;
+    QString currentVersion;
+    QString mcVersion;
+    QString mods;
+    QString logo;
+
+    //Technical data
+    QString dir;
+    QString file; //<- Url in the xml, but doesn't make much sense
+
+    bool bugged = false;
+    bool broken = false;
+
+    PackType type;
+    QString packCode;
+};
+
+typedef QList<Modpack> ModpackList;
+
+}
+
+//We need it for the proxy model
+Q_DECLARE_METATYPE(LegacyFTB::Modpack)

launcher/modplatform/legacy_ftb/PackInstallTask.cpp

@@ -0,0 +1,214 @@
+#include "PackInstallTask.h"
+
+#include "Env.h"
+#include "MMCZip.h"
+
+#include "BaseInstance.h"
+#include "FileSystem.h"
+#include "settings/INISettingsObject.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
+#include "minecraft/GradleSpecifier.h"
+#include "BuildConfig.h"
+
+#include <QtConcurrent>
+
+namespace LegacyFTB {
+
+PackInstallTask::PackInstallTask(Modpack pack, QString version)
+{
+    m_pack = pack;
+    m_version = version;
+}
+
+void PackInstallTask::executeTask()
+{
+    downloadPack();
+}
+
+void PackInstallTask::downloadPack()
+{
+    setStatus(tr("Downloading zip for %1").arg(m_pack.name));
+
+    auto packoffset = QString("%1/%2/%3").arg(m_pack.dir, m_version.replace(".", "_"), m_pack.file);
+    auto entry = ENV.metacache()->resolveEntry("FTBPacks", packoffset);
+    NetJob *job = new NetJob("Download FTB Pack");
+
+    entry->setStale(true);
+    QString url;
+    if(m_pack.type == PackType::Private)
+    {
+        url = QString(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "privatepacks/%1").arg(packoffset);
+    }
+    else
+    {
+        url = QString(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "modpacks/%1").arg(packoffset);
+    }
+    job->addNetAction(Net::Download::makeCached(url, entry));
+    archivePath = entry->getFullPath();
+
+    netJobContainer.reset(job);
+    connect(job, &NetJob::succeeded, this, &PackInstallTask::onDownloadSucceeded);
+    connect(job, &NetJob::failed, this, &PackInstallTask::onDownloadFailed);
+    connect(job, &NetJob::progress, this, &PackInstallTask::onDownloadProgress);
+    job->start();
+
+    progress(1, 4);
+}
+
+void PackInstallTask::onDownloadSucceeded()
+{
+    abortable = false;
+    unzip();
+}
+
+void PackInstallTask::onDownloadFailed(QString reason)
+{
+    abortable = false;
+    emitFailed(reason);
+}
+
+void PackInstallTask::onDownloadProgress(qint64 current, qint64 total)
+{
+    abortable = true;
+    progress(current, total * 4);
+    setStatus(tr("Downloading zip for %1 (%2%)").arg(m_pack.name).arg(current / 10));
+}
+
+void PackInstallTask::unzip()
+{
+    progress(2, 4);
+    setStatus(tr("Extracting modpack"));
+    QDir extractDir(m_stagingPath);
+
+    m_packZip.reset(new QuaZip(archivePath));
+    if(!m_packZip->open(QuaZip::mdUnzip))
+    {
+        emitFailed(tr("Failed to open modpack file %1!").arg(archivePath));
+        return;
+    }
+
+    m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, archivePath, extractDir.absolutePath() + "/unzip");
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &PackInstallTask::onUnzipFinished);
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &PackInstallTask::onUnzipCanceled);
+    m_extractFutureWatcher.setFuture(m_extractFuture);
+}
+
+void PackInstallTask::onUnzipFinished()
+{
+    install();
+}
+
+void PackInstallTask::onUnzipCanceled()
+{
+    emitAborted();
+}
+
+void PackInstallTask::install()
+{
+    progress(3, 4);
+    setStatus(tr("Installing modpack"));
+    QDir unzipMcDir(m_stagingPath + "/unzip/minecraft");
+    if(unzipMcDir.exists())
+    {
+        //ok, found minecraft dir, move contents to instance dir
+        if(!QDir().rename(m_stagingPath + "/unzip/minecraft", m_stagingPath + "/.minecraft"))
+        {
+            emitFailed(tr("Failed to move unzipped minecraft!"));
+            return;
+        }
+    }
+
+    QString instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
+    auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
+    instanceSettings->suspendSave();
+    instanceSettings->registerSetting("InstanceType", "Legacy");
+    instanceSettings->set("InstanceType", "OneSix");
+
+    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
+    auto components = instance.getPackProfile();
+    components->buildingFromScratch();
+    components->setComponentVersion("net.minecraft", m_pack.mcVersion, true);
+
+    bool fallback = true;
+
+    //handle different versions
+    QFile packJson(m_stagingPath + "/.minecraft/pack.json");
+    QDir jarmodDir = QDir(m_stagingPath + "/unzip/instMods");
+    if(packJson.exists())
+    {
+        packJson.open(QIODevice::ReadOnly | QIODevice::Text);
+        QJsonDocument doc = QJsonDocument::fromJson(packJson.readAll());
+        packJson.close();
+
+        //we only care about the libs
+        QJsonArray libs = doc.object().value("libraries").toArray();
+
+        foreach (const QJsonValue &value, libs)
+        {
+            QString nameValue = value.toObject().value("name").toString();
+            if(!nameValue.startsWith("net.minecraftforge"))
+            {
+                continue;
+            }
+
+            GradleSpecifier forgeVersion(nameValue);
+
+            components->setComponentVersion("net.minecraftforge", forgeVersion.version().replace(m_pack.mcVersion, "").replace("-", ""));
+            packJson.remove();
+            fallback = false;
+            break;
+        }
+
+    }
+
+    if(jarmodDir.exists())
+    {
+        qDebug() << "Found jarmods, installing...";
+
+        QStringList jarmods;
+        for (auto info: jarmodDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files))
+        {
+            qDebug() << "Jarmod:" << info.fileName();
+            jarmods.push_back(info.absoluteFilePath());
+        }
+
+        components->installJarMods(jarmods);
+        fallback = false;
+    }
+
+    //just nuke unzip directory, it s not needed anymore
+    FS::deletePath(m_stagingPath + "/unzip");
+
+    if(fallback)
+    {
+        //TODO: Some fallback mechanism... or just keep failing!
+        emitFailed(tr("No installation method found!"));
+        return;
+    }
+
+    components->saveNow();
+
+    progress(4, 4);
+
+    instance.setName(m_instName);
+    if(m_instIcon == "default")
+    {
+        m_instIcon = "ftb_logo";
+    }
+    instance.setIconKey(m_instIcon);
+    instanceSettings->resumeSave();
+
+    emitSucceeded();
+}
+
+bool PackInstallTask::abort()
+{
+    if(abortable)
+    {
+        return netJobContainer->abort();
+    }
+    return false;
+}
+
+}

launcher/modplatform/legacy_ftb/PackInstallTask.h

@@ -0,0 +1,55 @@
+#pragma once
+#include "InstanceTask.h"
+#include "net/NetJob.h"
+#include "quazip.h"
+#include "quazipdir.h"
+#include "meta/Index.h"
+#include "meta/Version.h"
+#include "meta/VersionList.h"
+#include "PackHelpers.h"
+
+#include <nonstd/optional>
+
+namespace LegacyFTB {
+
+class PackInstallTask : public InstanceTask
+{
+    Q_OBJECT
+
+public:
+    explicit PackInstallTask(Modpack pack, QString version);
+    virtual ~PackInstallTask(){}
+
+    bool canAbort() const override { return true; }
+    bool abort() override;
+
+protected:
+    //! Entry point for tasks.
+    virtual void executeTask() override;
+
+private:
+    void downloadPack();
+    void unzip();
+    void install();
+
+private slots:
+    void onDownloadSucceeded();
+    void onDownloadFailed(QString reason);
+    void onDownloadProgress(qint64 current, qint64 total);
+
+    void onUnzipFinished();
+    void onUnzipCanceled();
+
+private: /* data */
+    bool abortable = false;
+    std::unique_ptr<QuaZip> m_packZip;
+    QFuture<nonstd::optional<QStringList>> m_extractFuture;
+    QFutureWatcher<nonstd::optional<QStringList>> m_extractFutureWatcher;
+    NetJobPtr netJobContainer;
+    QString archivePath;
+
+    Modpack m_pack;
+    QString m_version;
+};
+
+}

launcher/modplatform/legacy_ftb/PrivatePackManager.cpp

@@ -0,0 +1,41 @@
+#include "PrivatePackManager.h"
+
+#include <QDebug>
+
+#include "FileSystem.h"
+
+namespace LegacyFTB {
+
+void PrivatePackManager::load()
+{
+    try
+    {
+        currentPacks = QString::fromUtf8(FS::read(m_filename)).split('\n', QString::SkipEmptyParts).toSet();
+        dirty = false;
+    }
+    catch(...)
+    {
+        currentPacks = {};
+        qWarning() << "Failed to read third party FTB pack codes from" << m_filename;
+    }
+}
+
+void PrivatePackManager::save() const
+{
+    if(!dirty)
+    {
+        return;
+    }
+    try
+    {
+        QStringList list = currentPacks.toList();
+        FS::write(m_filename, list.join('\n').toUtf8());
+        dirty = false;
+    }
+    catch(...)
+    {
+        qWarning() << "Failed to write third party FTB pack codes to" << m_filename;
+    }
+}
+
+}

launcher/modplatform/legacy_ftb/PrivatePackManager.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <QSet>
+#include <QString>
+#include <QFile>
+
+namespace LegacyFTB {
+
+class PrivatePackManager
+{
+public:
+    ~PrivatePackManager()
+    {
+        save();
+    }
+    void load();
+    void save() const;
+    bool empty() const
+    {
+        return currentPacks.empty();
+    }
+    const QSet<QString> &getCurrentPackCodes() const
+    {
+        return currentPacks;
+    }
+    void add(const QString &code)
+    {
+        currentPacks.insert(code);
+        dirty = true;
+    }
+    void remove(const QString &code)
+    {
+        currentPacks.remove(code);
+        dirty = true;
+    }
+
+private:
+    QSet<QString> currentPacks;
+    QString m_filename = "private_packs.txt";
+    mutable bool dirty = false;
+};
+
+}