new builds menu and modloaders implementation

2026-08-27 09:21:51 +03:00
parent 5bc59f8018
commit 168884127b
23 changed files with 3979 additions and 1081 deletions
@@ -0,0 +1,438 @@
+#include "buildswitcher.h"
+
+#include "buildarchiveworker.h"
+#include "launcherpaths.h"
+
+#include <QDateTime>
+#include <QDir>
+#include <QDirIterator>
+#include <QFile>
+#include <QFileInfo>
+#include <QJsonDocument>
+#include <QSaveFile>
+#include <QStorageInfo>
+#include <QThread>
+#include <QUuid>
+
+namespace {
+
+const QString kIndexFile = QStringLiteral("index.json");
+const QString kStateSwitching = QStringLiteral("switching");
+const QString kStateIdle = QStringLiteral("idle");
+
+// Запас на архив: точный размер заранее неизвестен, но упасть на середине
+// записи из-за полного диска хуже, чем отказаться заранее.
+constexpr qint64 kFreeSpaceSlackBytes = 256LL * 1024 * 1024;
+
+// Имя файла из названия сборки: оно попадает в файловую систему, поэтому всё
+// небезопасное заменяется подчёркиванием.
+QString slug(const QString &name)
+{
+    QString result;
+    result.reserve(name.size());
+    for (const QChar c : name) {
+        if (c.isLetterOrNumber() || c == u'-' || c == u'_')
+            result.append(c);
+        else if (c.isSpace() || c == u'.')
+            result.append(u'_');
+    }
+    while (result.startsWith(u'_'))
+        result.remove(0, 1);
+    return result.isEmpty() ? QStringLiteral("build") : result.left(48);
+}
+
+qint64 directorySize(const QString &path, const QStringList &excludeTop)
+{
+    qint64 total = 0;
+    const QDir root(path);
+    const QFileInfoList top = root.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot
+                                                 | QDir::Hidden | QDir::System);
+    for (const QFileInfo &entry : top) {
+        if (excludeTop.contains(entry.fileName()) || entry.isSymLink())
+            continue;
+        if (entry.isFile()) {
+            total += entry.size();
+            continue;
+        }
+        QDirIterator it(entry.absoluteFilePath(),
+                        QDir::Files | QDir::Hidden | QDir::System | QDir::NoSymLinks,
+                        QDirIterator::Subdirectories);
+        while (it.hasNext()) {
+            it.next();
+            total += it.fileInfo().size();
+        }
+    }
+    return total;
+}
+
+} // namespace
+
+QStringList BuildSwitcher::sharedTopLevel()
+{
+    // Общий кэш, одинаковый для всех сборок и всегда восстановимый загрузкой.
+    // versions/ здесь не случайно: без libraries/ описания версий бесполезны, а
+    // две сборки на одной версии игры иначе таскали бы по копии клиентского jar.
+    // Чем сборка запускается, помнит resolvedVersionId, а не набор папок.
+    return {QStringLiteral("assets"),
+            QStringLiteral("libraries"),
+            QStringLiteral("versions"),
+            QStringLiteral("launcher_profiles.json"),
+            QStringLiteral("runtime")};
+}
+
+BuildSwitcher::BuildSwitcher(QObject *parent)
+    : QObject(parent)
+    , m_thread(new QThread(this))
+    , m_worker(new BuildArchiveWorker)
+{
+    m_worker->moveToThread(m_thread);
+    connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
+    connect(m_worker, &BuildArchiveWorker::finished, this, &BuildSwitcher::onWorkerFinished);
+    connect(m_worker, &BuildArchiveWorker::progress, this, &BuildSwitcher::onWorkerProgress);
+    m_thread->start();
+
+    sweepTempArchives();
+}
+
+BuildSwitcher::~BuildSwitcher()
+{
+    m_worker->requestCancel();
+    m_thread->quit();
+    m_thread->wait(5000);
+}
+
+double BuildSwitcher::fraction() const
+{
+    if (m_state == Idle || m_total <= 0)
+        return -1.0;
+    return double(m_done) / double(m_total);
+}
+
+QString BuildSwitcher::buildDir(int buildId) const
+{
+    return LauncherPaths::buildStorageDir() + u'/' + QString::number(buildId);
+}
+
+// На сборку — ровно один архив: имя с датой меняется от переключения к
+// переключению, поэтому ищем по расширению, а не по имени.
+QString BuildSwitcher::archivePathOf(int buildId) const
+{
+    const QDir dir(buildDir(buildId));
+    const QStringList zips = dir.entryList({QStringLiteral("*.zip")}, QDir::Files, QDir::Time);
+    return zips.isEmpty() ? QString() : dir.absoluteFilePath(zips.first());
+}
+
+void BuildSwitcher::setStage(const QString &stage)
+{
+    m_stage = stage;
+    emit progressChanged();
+}
+
+void BuildSwitcher::switchTo(int fromBuildId,
+                             const QString &fromName,
+                             int toBuildId,
+                             const QString &toName,
+                             const QString &gameDir)
+{
+    if (m_state != Idle) {
+        emit failed(toBuildId, tr("Смена сборки уже выполняется"), true);
+        return;
+    }
+
+    QString rootError;
+    if (!LauncherPaths::ensureRootExists(&rootError)) {
+        emit failed(toBuildId, rootError, true);
+        return;
+    }
+
+    m_fromId = fromBuildId;
+    m_toId = toBuildId;
+    m_fromName = fromName;
+    m_toName = toName;
+    m_gameDir = gameDir;
+    m_done = 0;
+    m_total = 0;
+    m_worker->clearCancel();
+
+    // Первая сборка за всё время: архивировать нечего, сразу разворачиваем цель.
+    if (fromBuildId < 0 || !QDir(gameDir).exists()) {
+        m_state = Clearing;
+        beginClearing();
+        return;
+    }
+
+    if (!QDir().mkpath(buildDir(fromBuildId))) {
+        emit failed(toBuildId,
+                    tr("Не удалось создать %1")
+                        .arg(QDir::toNativeSeparators(buildDir(fromBuildId))),
+                    true);
+        return;
+    }
+
+    const qint64 needed = directorySize(gameDir, sharedTopLevel()) + kFreeSpaceSlackBytes;
+    const QStorageInfo storage(LauncherPaths::buildStorageDir());
+    if (storage.isValid() && storage.bytesAvailable() < needed) {
+        emit failed(toBuildId,
+                    tr("Недостаточно места для архива сборки «%1»: нужно около %2 МБ")
+                        .arg(fromName)
+                        .arg(needed / (1024 * 1024)),
+                    true);
+        return;
+    }
+
+    m_tempZip = buildDir(fromBuildId) + QStringLiteral("/.tmp-")
+                + QUuid::createUuid().toString(QUuid::Id128) + QStringLiteral(".zip");
+
+    m_state = Archiving;
+    setStage(tr("Сохранение сборки «%1»").arg(fromName));
+    requestArchive(gameDir, m_tempZip, sharedTopLevel());
+}
+
+void BuildSwitcher::cancel()
+{
+    // Отмена имеет смысл только на архивации: после очистки папки отступать
+    // уже некуда, там нужно доводить дело до конца.
+    if (m_state == Archiving)
+        m_worker->requestCancel();
+}
+
+void BuildSwitcher::requestArchive(const QString &gameDir,
+                                   const QString &tempZip,
+                                   const QStringList &exclude)
+{
+    QMetaObject::invokeMethod(m_worker, "archive", Qt::QueuedConnection,
+                              Q_ARG(QString, gameDir), Q_ARG(QString, tempZip),
+                              Q_ARG(QStringList, exclude));
+}
+
+void BuildSwitcher::requestClear(const QString &gameDir, const QStringList &keep)
+{
+    QMetaObject::invokeMethod(m_worker, "clear", Qt::QueuedConnection,
+                              Q_ARG(QString, gameDir), Q_ARG(QStringList, keep));
+}
+
+void BuildSwitcher::requestRestore(const QString &zipPath, const QString &gameDir)
+{
+    QMetaObject::invokeMethod(m_worker, "restore", Qt::QueuedConnection,
+                              Q_ARG(QString, zipPath), Q_ARG(QString, gameDir));
+}
+
+void BuildSwitcher::onWorkerProgress(int done, int total, const QString &currentPath)
+{
+    m_done = done;
+    m_total = total;
+    m_status = currentPath;
+    emit progressChanged();
+}
+
+void BuildSwitcher::onWorkerFinished(bool ok, const QString &error)
+{
+    switch (m_state) {
+    case Idle:
+        return;
+    case Archiving:
+        if (!ok) {
+            QFile::remove(m_tempZip);
+            fail(error, /*gameDirIntact=*/true);
+            return;
+        }
+        commitArchive();
+        return;
+    case Clearing:
+        if (!ok) {
+            // Папка осталась разобранной: активной сборкой считается прежняя,
+            // отметка о незавершённом переключении в index.json остаётся.
+            fail(error, /*gameDirIntact=*/false);
+            return;
+        }
+        beginRestoring();
+        return;
+    case Restoring:
+        if (!ok) {
+            fail(error, /*gameDirIntact=*/false);
+            return;
+        }
+        finish();
+        return;
+    }
+}
+
+void BuildSwitcher::commitArchive()
+{
+    const QString target = buildDir(m_fromId) + u'/'
+                           + QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd"))
+                           + u'_' + slug(m_fromName) + QStringLiteral(".zip");
+
+    // На сборку — один архив: новый встаёт на место, все прежние уходят.
+    if (QFile::exists(target) && !QFile::remove(target)) {
+        QFile::remove(m_tempZip);
+        fail(tr("Не удалось заменить архив %1").arg(QDir::toNativeSeparators(target)), true);
+        return;
+    }
+    if (!QFile::rename(m_tempZip, target)) {
+        QFile::remove(m_tempZip);
+        fail(tr("Не удалось сохранить архив %1").arg(QDir::toNativeSeparators(target)), true);
+        return;
+    }
+
+    const QDir dir(buildDir(m_fromId));
+    const QStringList zips = dir.entryList({QStringLiteral("*.zip")}, QDir::Files);
+    for (const QString &name : zips) {
+        if (dir.absoluteFilePath(name) != target)
+            QFile::remove(dir.absoluteFilePath(name));
+    }
+
+    // Отметка ставится до первого разрушающего действия: по ней следующий
+    // запуск поймёт, что переключение оборвалось на середине.
+    QJsonObject index = readIndex();
+    index.insert(QStringLiteral("state"), kStateSwitching);
+    index.insert(QStringLiteral("from"), m_fromId);
+    index.insert(QStringLiteral("to"), m_toId);
+    QJsonObject builds = index.value(QStringLiteral("builds")).toObject();
+    builds.insert(QString::number(m_fromId),
+                  QJsonObject{{QStringLiteral("archive"), QFileInfo(target).fileName()},
+                              {QStringLiteral("name"), m_fromName},
+                              {QStringLiteral("savedAt"),
+                               QDateTime::currentDateTimeUtc().toString(Qt::ISODate)}});
+    index.insert(QStringLiteral("builds"), builds);
+    writeIndex(index);
+
+    m_state = Clearing;
+    beginClearing();
+}
+
+void BuildSwitcher::beginClearing()
+{
+    setStage(tr("Подготовка сборки «%1»").arg(m_toName));
+    requestClear(m_gameDir, sharedTopLevel());
+}
+
+void BuildSwitcher::beginRestoring()
+{
+    const QString archive = archivePathOf(m_toId);
+    if (archive.isEmpty()) {
+        // Сборка ещё ни разу не запускалась: пустая .minecraft рядом с общими
+        // кэшами — это и есть её правильное начальное состояние.
+        m_state = Restoring;
+        finish();
+        return;
+    }
+
+    m_state = Restoring;
+    setStage(tr("Восстановление сборки «%1»").arg(m_toName));
+    requestRestore(archive, m_gameDir);
+}
+
+void BuildSwitcher::finish()
+{
+    QJsonObject index = readIndex();
+    index.insert(QStringLiteral("state"), kStateIdle);
+    index.insert(QStringLiteral("active"), m_toId);
+    index.remove(QStringLiteral("from"));
+    index.remove(QStringLiteral("to"));
+    writeIndex(index);
+
+    const int toId = m_toId;
+    m_state = Idle;
+    m_stage.clear();
+    m_status.clear();
+    m_done = m_total = 0;
+    emit progressChanged();
+    emit finished(toId);
+}
+
+void BuildSwitcher::fail(const QString &message, bool gameDirIntact)
+{
+    const int toId = m_toId;
+    m_state = Idle;
+    m_stage.clear();
+    m_status.clear();
+    m_done = m_total = 0;
+    emit progressChanged();
+    emit failed(toId, message, gameDirIntact);
+}
+
+// ── Незавершённое переключение ─────────────────────────────────────────────
+
+QString BuildSwitcher::interruptedSwitchWarning() const
+{
+    const QJsonObject index = readIndex();
+    if (index.value(QStringLiteral("state")).toString() != kStateSwitching)
+        return {};
+
+    const int toId = index.value(QStringLiteral("to")).toInt(-1);
+    const QJsonObject builds = index.value(QStringLiteral("builds")).toObject();
+    const QString name = builds.value(QString::number(toId))
+                             .toObject()
+                             .value(QStringLiteral("name"))
+                             .toString();
+    return tr("Прошлая смена сборки%1 не завершилась — восстанавливаем содержимое .minecraft.")
+        .arg(name.isEmpty() ? QString() : tr(" на «%1»").arg(name));
+}
+
+void BuildSwitcher::resumeInterrupted(const QString &gameDir)
+{
+    const QJsonObject index = readIndex();
+    if (index.value(QStringLiteral("state")).toString() != kStateSwitching)
+        return;
+
+    const int toId = index.value(QStringLiteral("to")).toInt(-1);
+    if (toId < 0 || m_state != Idle)
+        return;
+
+    // Архив исходной сборки уже записан целиком — доигрываем только вторую
+    // половину: очистку и распаковку цели.
+    m_fromId = -1;
+    m_toId = toId;
+    m_toName = index.value(QStringLiteral("builds"))
+                   .toObject()
+                   .value(QString::number(toId))
+                   .toObject()
+                   .value(QStringLiteral("name"))
+                   .toString();
+    m_gameDir = gameDir;
+    m_done = m_total = 0;
+    m_worker->clearCancel();
+    m_state = Clearing;
+    beginClearing();
+}
+
+// ── Реестр архивов ─────────────────────────────────────────────────────────
+
+QJsonObject BuildSwitcher::readIndex() const
+{
+    QFile file(LauncherPaths::buildStorageDir() + u'/' + kIndexFile);
+    if (!file.open(QIODevice::ReadOnly))
+        return {};
+    return QJsonDocument::fromJson(file.readAll()).object();
+}
+
+void BuildSwitcher::writeIndex(const QJsonObject &index) const
+{
+    if (!LauncherPaths::ensureRootExists())
+        return;
+    QSaveFile file(LauncherPaths::buildStorageDir() + u'/' + kIndexFile);
+    if (!file.open(QIODevice::WriteOnly))
+        return;
+    const QByteArray payload = QJsonDocument(index).toJson(QJsonDocument::Indented);
+    if (file.write(payload) != payload.size()) {
+        file.cancelWriting();
+        return;
+    }
+    file.commit();
+}
+
+// Оборванная запись архива оставляет .tmp-*.zip: он никому не нужен и может
+// занимать гигабайты.
+void BuildSwitcher::sweepTempArchives() const
+{
+    QDir root(LauncherPaths::buildStorageDir());
+    const QStringList builds = root.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+    for (const QString &build : builds) {
+        QDir dir(root.absoluteFilePath(build));
+        const QStringList leftovers =
+            dir.entryList({QStringLiteral(".tmp-*.zip")}, QDir::Files | QDir::Hidden);
+        for (const QString &name : leftovers)
+            QFile::remove(dir.absoluteFilePath(name));
+    }
+}