839 lines
30 KiB
C++
839 lines
30 KiB
C++
#include "versioninstaller.h"
|
|
#include "localization.h"
|
|
|
|
#include "gamelauncher.h"
|
|
#include "versionmanifestservice.h"
|
|
|
|
#include <QDir>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
#include <QNetworkAccessManager>
|
|
#include <QNetworkReply>
|
|
#include <QNetworkRequest>
|
|
#include <QSaveFile>
|
|
#include <QTimer>
|
|
|
|
#include <algorithm>
|
|
#include <utility>
|
|
|
|
namespace {
|
|
|
|
// Своя очередь, а не тысячи QNetworkReply внутри QNetworkAccessManager: там они
|
|
// встают в невидимую очередь, каждый со своим объектом и без управления отменой.
|
|
constexpr int kMaxParallel = 8;
|
|
constexpr int kMaxAttempts = 3;
|
|
constexpr int kTransferTimeoutMs = 30000;
|
|
// Копирование тысяч мелких файлов одним циклом заморозило бы окно на секунды.
|
|
constexpr int kLegacyCopiesPerTick = 64;
|
|
// Столько уже имеющихся файлов проверяем за один заход, остальное — следующим.
|
|
constexpr int kSkipsPerTick = 256;
|
|
constexpr int kMaxInheritDepth = 10;
|
|
|
|
const QString kResourcesUrl = QStringLiteral("https://resources.download.minecraft.net/");
|
|
|
|
// Хэш из json попадает в путь на диске — принимаем только настоящий sha1.
|
|
bool isSha1Hex(const QString &value)
|
|
{
|
|
if (value.size() != 40)
|
|
return false;
|
|
for (const QChar c : value) {
|
|
if (!((c >= u'0' && c <= u'9') || (c >= u'a' && c <= u'f') || (c >= u'A' && c <= u'F')))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Относительный путь из json нельзя подставлять как есть: «../..» увёл бы
|
|
// запись за пределы .minecraft.
|
|
bool isSafeRelativePath(const QString &path)
|
|
{
|
|
if (path.isEmpty() || path.startsWith(u'/') || path.contains(u'\\') || path.contains(u':'))
|
|
return false;
|
|
const QStringList parts = path.split(u'/');
|
|
for (const QString &part : parts) {
|
|
if (part.isEmpty() || part == QLatin1String(".") || part == QLatin1String(".."))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Одиночный сегмент: id версии, id индекса ресурсов, имя конфига логирования.
|
|
bool isSafeRelativeSegment(const QString &value)
|
|
{
|
|
return !value.contains(u'/') && isSafeRelativePath(value);
|
|
}
|
|
|
|
QString versionJsonPath(const QString &gameDir, const QString &id)
|
|
{
|
|
return gameDir + QStringLiteral("/versions/") + id + u'/' + id + QStringLiteral(".json");
|
|
}
|
|
|
|
bool isTransient(QNetworkReply::NetworkError error, int httpStatus)
|
|
{
|
|
if (httpStatus == 429 || httpStatus >= 500)
|
|
return true;
|
|
switch (error) {
|
|
case QNetworkReply::RemoteHostClosedError:
|
|
case QNetworkReply::TimeoutError:
|
|
case QNetworkReply::TemporaryNetworkFailureError:
|
|
case QNetworkReply::NetworkSessionFailedError:
|
|
case QNetworkReply::UnknownNetworkError:
|
|
case QNetworkReply::ProxyTimeoutError:
|
|
case QNetworkReply::ContentReSendError:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
QString fileNameOf(const QString &path)
|
|
{
|
|
return QFileInfo(path).fileName();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
VersionInstaller::VersionInstaller(VersionManifestService *manifest, QObject *parent)
|
|
: QObject(parent)
|
|
, m_manifest(manifest)
|
|
, m_network(new QNetworkAccessManager(this))
|
|
, m_progressTimer(new QTimer(this))
|
|
, m_legacyTimer(new QTimer(this))
|
|
{
|
|
// Восемь параллельных ответов шлют downloadProgress на каждый кусок данных:
|
|
// без склейки привязки в QML пересчитывались бы сотни раз в секунду.
|
|
m_progressTimer->setInterval(100);
|
|
connect(m_progressTimer, &QTimer::timeout, this, &VersionInstaller::flushProgress);
|
|
|
|
m_legacyTimer->setInterval(0);
|
|
connect(m_legacyTimer, &QTimer::timeout, this, &VersionInstaller::legacyTick);
|
|
}
|
|
|
|
VersionInstaller::~VersionInstaller()
|
|
{
|
|
// Из деструктора сигналы уже некому слушать, а QSaveFile сам выбросит
|
|
// недописанные временные файлы.
|
|
blockSignals(true);
|
|
cancel();
|
|
}
|
|
|
|
// ── Прогресс ───────────────────────────────────────────────────────────────
|
|
|
|
qint64 VersionInstaller::bytesDone() const
|
|
{
|
|
qint64 total = m_bytesSettled;
|
|
for (const auto &context : m_active)
|
|
total += context->received;
|
|
return total;
|
|
}
|
|
|
|
double VersionInstaller::fraction() const
|
|
{
|
|
if (m_bytesTotal <= 0)
|
|
return -1.0;
|
|
const double value = double(bytesDone()) / double(m_bytesTotal);
|
|
return std::clamp(value, 0.0, 1.0);
|
|
}
|
|
|
|
void VersionInstaller::setStage(const QString &stage)
|
|
{
|
|
m_stage = stage;
|
|
scheduleProgress();
|
|
}
|
|
|
|
void VersionInstaller::scheduleProgress()
|
|
{
|
|
m_progressDirty = true;
|
|
if (!m_progressTimer->isActive())
|
|
m_progressTimer->start();
|
|
}
|
|
|
|
void VersionInstaller::flushProgress()
|
|
{
|
|
if (!m_progressDirty) {
|
|
if (!m_running)
|
|
m_progressTimer->stop();
|
|
return;
|
|
}
|
|
m_progressDirty = false;
|
|
emit progressChanged();
|
|
}
|
|
|
|
// ── Очередь установок ──────────────────────────────────────────────────────
|
|
|
|
bool VersionInstaller::isQueued(const QString &versionId) const
|
|
{
|
|
for (const auto &entry : m_pendingInstalls) {
|
|
if (entry.second == versionId)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void VersionInstaller::install(const QString &gameDir, const QString &versionId)
|
|
{
|
|
const QString id = versionId.trimmed();
|
|
if (id.isEmpty())
|
|
return;
|
|
|
|
if (!isSafeRelativeSegment(id)) {
|
|
emit failed(id, Loc::text("version.error.invalidName").arg(id));
|
|
return;
|
|
}
|
|
if (m_canceling) {
|
|
emit failed(id, Loc::text("version.error.cancelPending"));
|
|
return;
|
|
}
|
|
if (m_versionId == id || isQueued(id))
|
|
return;
|
|
|
|
m_pendingInstalls.enqueue({gameDir, id});
|
|
if (!m_running)
|
|
startNext();
|
|
}
|
|
|
|
void VersionInstaller::startNext()
|
|
{
|
|
if (m_pendingInstalls.isEmpty()) {
|
|
m_running = false;
|
|
m_versionId.clear();
|
|
m_stage.clear();
|
|
m_currentLabel.clear();
|
|
m_progressTimer->stop();
|
|
emit progressChanged();
|
|
return;
|
|
}
|
|
|
|
const auto entry = m_pendingInstalls.dequeue();
|
|
m_gameDir = entry.first;
|
|
m_versionId = entry.second;
|
|
m_versionJson = {};
|
|
m_version = {};
|
|
m_queue.clear();
|
|
m_warnings.clear();
|
|
m_assetObjects = {};
|
|
m_assetsVirtual = false;
|
|
m_assetsMapToResources = false;
|
|
m_legacyCopies.clear();
|
|
m_legacyIndex = 0;
|
|
m_bytesSettled = 0;
|
|
m_bytesTotal = 0;
|
|
m_assetsDeclaredTotal = 0;
|
|
|
|
const bool wasRunning = m_running;
|
|
m_running = true;
|
|
if (!wasRunning)
|
|
emit started(m_versionId);
|
|
setStage(Loc::text("version.progress.fetchingList"));
|
|
emit progressChanged();
|
|
|
|
resolveManifestEntry();
|
|
}
|
|
|
|
void VersionInstaller::resolveManifestEntry()
|
|
{
|
|
const QString id = m_versionId;
|
|
m_manifest->ensureLoaded([this, id](bool ok, const QString &warning) {
|
|
if (!m_running || m_canceling || m_versionId != id)
|
|
return;
|
|
|
|
if (!ok) {
|
|
QFile local(versionJsonPath(m_gameDir, id));
|
|
if (local.open(QIODevice::ReadOnly)) {
|
|
adoptVersionJson(local.readAll(), /*alreadySaved=*/true);
|
|
return;
|
|
}
|
|
failInstall(warning.isEmpty() ? Loc::text("version.error.listUnavailable") : warning);
|
|
return;
|
|
}
|
|
|
|
const auto entry = m_manifest->find(id);
|
|
if (entry) {
|
|
fetchVersionJson(entry->url, entry->sha1);
|
|
return;
|
|
}
|
|
|
|
// Версии нет в манифесте, но описание могло уже лечь на диск: так
|
|
// ставятся сборки модлоадеров, чьи id Mojang не знает.
|
|
QFile local(versionJsonPath(m_gameDir, id));
|
|
if (local.open(QIODevice::ReadOnly)) {
|
|
adoptVersionJson(local.readAll(), /*alreadySaved=*/true);
|
|
return;
|
|
}
|
|
|
|
// Иначе это вручную вписанный id сборки — сообщение не должно
|
|
// выглядеть как сетевая ошибка.
|
|
failInstall(Loc::text("version.error.notInManifest")
|
|
.arg(id));
|
|
});
|
|
}
|
|
|
|
void VersionInstaller::fetchVersionJson(const QUrl &url, const QString &expectedSha1)
|
|
{
|
|
setStage(Loc::text("version.progress.description"));
|
|
m_currentLabel = m_versionId + QStringLiteral(".json");
|
|
|
|
QNetworkRequest request{url};
|
|
request.setAttribute(QNetworkRequest::RedirectPolicyAttribute,
|
|
QNetworkRequest::NoLessSafeRedirectPolicy);
|
|
request.setTransferTimeout(kTransferTimeoutMs);
|
|
|
|
const QString id = m_versionId;
|
|
QNetworkReply *reply = m_network->get(request);
|
|
connect(reply, &QNetworkReply::finished, this, [this, reply, expectedSha1, id] {
|
|
reply->deleteLater();
|
|
if (!m_running || m_canceling || m_versionId != id)
|
|
return;
|
|
|
|
if (reply->error() != QNetworkReply::NoError) {
|
|
failInstall(Loc::text("version.error.descriptionFetchFailed").arg(reply->errorString()));
|
|
return;
|
|
}
|
|
|
|
const QByteArray payload = reply->readAll();
|
|
if (!expectedSha1.isEmpty()) {
|
|
const QString actual = QString::fromLatin1(
|
|
QCryptographicHash::hash(payload, QCryptographicHash::Sha1).toHex());
|
|
if (actual.compare(expectedSha1, Qt::CaseInsensitive) != 0) {
|
|
failInstall(Loc::text("version.error.descriptionChecksum").arg(id));
|
|
return;
|
|
}
|
|
}
|
|
|
|
adoptVersionJson(payload, /*alreadySaved=*/false);
|
|
});
|
|
}
|
|
|
|
// Общий хвост для описания версии, откуда бы оно ни пришло: из сети или уже
|
|
// лежащим на диске (сборки модлоадеров кладут его туда сами).
|
|
void VersionInstaller::adoptVersionJson(const QByteArray &payload, bool alreadySaved)
|
|
{
|
|
const QString id = m_versionId;
|
|
|
|
m_versionJson = QJsonDocument::fromJson(payload).object();
|
|
if (m_versionJson.isEmpty()) {
|
|
failInstall(Loc::text("version.error.descriptionUnparsable").arg(id));
|
|
return;
|
|
}
|
|
|
|
if (!alreadySaved) {
|
|
const QString directory = m_gameDir + QStringLiteral("/versions/") + id;
|
|
if (!QDir().mkpath(directory)) {
|
|
failInstall(Loc::text("common.error.createFailed").arg(QDir::toNativeSeparators(directory)));
|
|
return;
|
|
}
|
|
|
|
QSaveFile file(directory + u'/' + id + QStringLiteral(".json"));
|
|
if (!file.open(QIODevice::WriteOnly) || file.write(payload) != payload.size()
|
|
|| !file.commit()) {
|
|
file.cancelWriting();
|
|
failInstall(Loc::text("common.error.versionSaveFailed").arg(id));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Ванильные версии ничего не наследуют, но сборка могла бы — тогда
|
|
// сначала ставим родителя, а потом возвращаемся к этой версии.
|
|
const QString parentId = m_versionJson.value(QStringLiteral("inheritsFrom")).toString();
|
|
if (!parentId.isEmpty() && isSafeRelativeSegment(parentId)
|
|
&& !QFile::exists(versionJsonPath(m_gameDir, parentId))) {
|
|
if (m_inheritDepth >= kMaxInheritDepth) {
|
|
failInstall(Loc::text("common.error.inheritsChainTooLong").arg(id));
|
|
return;
|
|
}
|
|
++m_inheritDepth;
|
|
m_pendingInstalls.prepend({m_gameDir, id});
|
|
m_pendingInstalls.prepend({m_gameDir, parentId});
|
|
abandonCurrent();
|
|
return;
|
|
}
|
|
|
|
m_inheritDepth = 0;
|
|
if (prepareTasks())
|
|
pump();
|
|
}
|
|
|
|
// ── Составление списка файлов ──────────────────────────────────────────────
|
|
|
|
void VersionInstaller::enqueue(DownloadTask task)
|
|
{
|
|
if (task.url.scheme() != QLatin1String("https")) {
|
|
// Подменённое описание версии не должно уводить загрузку на чужой адрес.
|
|
m_warnings << Loc::text("version.warning.skippedBadUrl").arg(task.label);
|
|
return;
|
|
}
|
|
m_bytesTotal += task.size;
|
|
m_queue.enqueue(std::move(task));
|
|
}
|
|
|
|
bool VersionInstaller::prepareTasks()
|
|
{
|
|
setStage(Loc::text("version.progress.preparing"));
|
|
|
|
QString error;
|
|
// features пустые намеренно: Mojang отбирает библиотеки только по ОС,
|
|
// а feature-правила живут в arguments, которые установщику не нужны.
|
|
m_version = VersionLoader::load(m_gameDir, m_versionId, {}, &error);
|
|
if (!m_version.isValid()) {
|
|
failInstall(error.isEmpty() ? Loc::text("common.error.versionReadFailed").arg(m_versionId)
|
|
: error);
|
|
return false;
|
|
}
|
|
|
|
const QJsonObject client = m_versionJson.value(QStringLiteral("downloads"))
|
|
.toObject()
|
|
.value(QStringLiteral("client"))
|
|
.toObject();
|
|
if (!client.isEmpty()) {
|
|
DownloadTask task;
|
|
task.kind = DownloadTask::ClientJar;
|
|
task.url = QUrl(client.value(QStringLiteral("url")).toString());
|
|
task.path = m_version.clientJarPath;
|
|
task.sha1 = client.value(QStringLiteral("sha1")).toString();
|
|
task.size = client.value(QStringLiteral("size")).toInteger();
|
|
task.label = fileNameOf(task.path);
|
|
enqueue(std::move(task));
|
|
}
|
|
|
|
// url, sha1 и size у библиотек уже разобраны VersionLoader — это готовые
|
|
// описания загрузки, разбирать json заново не нужно.
|
|
for (const MinecraftLibrary &library : std::as_const(m_version.libraries)) {
|
|
if (library.url.isEmpty() || !isSafeRelativePath(library.path)) {
|
|
m_warnings << Loc::text("version.error.libraryNoUrl").arg(library.name);
|
|
continue;
|
|
}
|
|
DownloadTask task;
|
|
task.kind = DownloadTask::Library;
|
|
task.url = QUrl(library.url);
|
|
task.path = m_gameDir + QStringLiteral("/libraries/") + library.path;
|
|
task.sha1 = library.sha1;
|
|
task.size = library.size;
|
|
task.label = library.name;
|
|
enqueue(std::move(task));
|
|
}
|
|
|
|
const QJsonObject assetIndex = m_versionJson.value(QStringLiteral("assetIndex")).toObject();
|
|
if (!assetIndex.isEmpty() && isSafeRelativeSegment(m_version.assetIndexId)) {
|
|
DownloadTask task;
|
|
task.kind = DownloadTask::AssetIndex;
|
|
task.url = QUrl(assetIndex.value(QStringLiteral("url")).toString());
|
|
task.path = m_gameDir + QStringLiteral("/assets/indexes/") + m_version.assetIndexId
|
|
+ QStringLiteral(".json");
|
|
task.sha1 = assetIndex.value(QStringLiteral("sha1")).toString();
|
|
task.size = assetIndex.value(QStringLiteral("size")).toInteger();
|
|
task.label = Loc::text("version.progress.assetIndex");
|
|
enqueue(std::move(task));
|
|
|
|
// totalSize — суммарный вес всех ресурсов, известный ещё до скачивания
|
|
// индекса: без него полоса первые секунды стояла бы и потом прыгнула.
|
|
m_assetsDeclaredTotal = assetIndex.value(QStringLiteral("totalSize")).toInteger();
|
|
m_bytesTotal += m_assetsDeclaredTotal;
|
|
}
|
|
|
|
const QJsonObject logging = m_versionJson.value(QStringLiteral("logging"))
|
|
.toObject()
|
|
.value(QStringLiteral("client"))
|
|
.toObject()
|
|
.value(QStringLiteral("file"))
|
|
.toObject();
|
|
const QString loggingId = logging.value(QStringLiteral("id")).toString();
|
|
if (!logging.isEmpty() && isSafeRelativeSegment(loggingId)) {
|
|
DownloadTask task;
|
|
task.kind = DownloadTask::LoggingConfig;
|
|
task.url = QUrl(logging.value(QStringLiteral("url")).toString());
|
|
task.path = m_gameDir + QStringLiteral("/assets/log_configs/") + loggingId;
|
|
task.sha1 = logging.value(QStringLiteral("sha1")).toString();
|
|
task.size = logging.value(QStringLiteral("size")).toInteger();
|
|
task.label = loggingId;
|
|
enqueue(std::move(task));
|
|
}
|
|
|
|
setStage(Loc::text("version.progress.gameFiles"));
|
|
return true;
|
|
}
|
|
|
|
// ── Движок загрузки ────────────────────────────────────────────────────────
|
|
|
|
void VersionInstaller::schedulePump()
|
|
{
|
|
if (m_pumpScheduled)
|
|
return;
|
|
m_pumpScheduled = true;
|
|
QTimer::singleShot(0, this, [this] {
|
|
m_pumpScheduled = false;
|
|
pump();
|
|
});
|
|
}
|
|
|
|
void VersionInstaller::pump()
|
|
{
|
|
if (!m_running || m_canceling)
|
|
return;
|
|
|
|
int skipped = 0;
|
|
while (m_active.size() < kMaxParallel && !m_queue.isEmpty()) {
|
|
const int before = m_active.size();
|
|
startTask(m_queue.dequeue());
|
|
// startTask мог провалить установку — тогда очередь уже разобрана.
|
|
if (!m_running || m_canceling)
|
|
return;
|
|
if (m_active.size() == before) {
|
|
// Файл уже был на месте — сотни таких проверок подряд ощутимы,
|
|
// поэтому остаток берём следующим проходом событийного цикла.
|
|
if (++skipped >= kSkipsPerTick && !m_queue.isEmpty()) {
|
|
schedulePump();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_queue.isEmpty() && m_active.isEmpty())
|
|
afterDownloads();
|
|
}
|
|
|
|
void VersionInstaller::startTask(DownloadTask task)
|
|
{
|
|
const QFileInfo info(task.path);
|
|
if (info.exists() && !m_verifyExisting && (task.size == 0 || info.size() == task.size)) {
|
|
m_bytesSettled += task.size;
|
|
if (task.kind == DownloadTask::AssetIndex)
|
|
expandAssetIndex(task.path);
|
|
scheduleProgress();
|
|
return;
|
|
}
|
|
|
|
// Временный файл QSaveFile ложится рядом с целевым, поэтому папка нужна
|
|
// даже до открытия.
|
|
if (!QDir().mkpath(info.absolutePath())) {
|
|
failInstall(Loc::text("common.error.createFailed").arg(QDir::toNativeSeparators(info.absolutePath())));
|
|
return;
|
|
}
|
|
|
|
auto context = std::make_shared<ActiveDownload>();
|
|
context->task = task;
|
|
context->file = std::make_unique<QSaveFile>(task.path);
|
|
if (!context->file->open(QIODevice::WriteOnly)) {
|
|
failInstall(Loc::text("common.error.openForWriteFailed").arg(QDir::toNativeSeparators(task.path)));
|
|
return;
|
|
}
|
|
|
|
QNetworkRequest request{task.url};
|
|
request.setAttribute(QNetworkRequest::RedirectPolicyAttribute,
|
|
QNetworkRequest::NoLessSafeRedirectPolicy);
|
|
// Без таймаута зависший сокет подвесил бы установку навсегда.
|
|
request.setTransferTimeout(kTransferTimeoutMs);
|
|
|
|
context->reply = m_network->get(request);
|
|
m_active.append(context);
|
|
m_currentLabel = task.label;
|
|
|
|
connect(context->reply, &QNetworkReply::readyRead, this, [this, context] {
|
|
const QByteArray chunk = context->reply->readAll();
|
|
if (chunk.isEmpty())
|
|
return;
|
|
context->hash.addData(chunk);
|
|
if (context->file->write(chunk) != chunk.size())
|
|
context->reply->abort();
|
|
});
|
|
connect(context->reply, &QNetworkReply::downloadProgress, this,
|
|
[this, context](qint64 received, qint64) {
|
|
context->received = received;
|
|
scheduleProgress();
|
|
});
|
|
connect(context->reply, &QNetworkReply::finished, this,
|
|
[this, context] { handleReplyFinished(context); });
|
|
|
|
scheduleProgress();
|
|
}
|
|
|
|
void VersionInstaller::handleReplyFinished(const std::shared_ptr<ActiveDownload> &context)
|
|
{
|
|
context->reply->deleteLater();
|
|
m_active.removeOne(context);
|
|
|
|
if (m_canceling) {
|
|
context->file->cancelWriting();
|
|
if (m_active.isEmpty())
|
|
finalizeCancel();
|
|
return;
|
|
}
|
|
if (!m_running)
|
|
return;
|
|
|
|
const int status =
|
|
context->reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
|
|
|
|
if (context->reply->error() != QNetworkReply::NoError) {
|
|
context->file->cancelWriting();
|
|
const QString reason = context->reply->errorString();
|
|
if (isTransient(context->reply->error(), status)) {
|
|
if (!retryOrFail(context->task, reason))
|
|
return;
|
|
} else {
|
|
failInstall(Loc::text("common.error.downloadFailed").arg(context->task.label, reason));
|
|
return;
|
|
}
|
|
pump();
|
|
return;
|
|
}
|
|
|
|
if (!context->task.sha1.isEmpty()) {
|
|
const QString actual = QString::fromLatin1(context->hash.result().toHex());
|
|
if (actual.compare(context->task.sha1, Qt::CaseInsensitive) != 0) {
|
|
context->file->cancelWriting();
|
|
if (!retryOrFail(context->task, Loc::text("common.error.checksumMismatch")))
|
|
return;
|
|
pump();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!context->file->commit()) {
|
|
failInstall(Loc::text("common.error.saveFailed").arg(QDir::toNativeSeparators(context->task.path)));
|
|
return;
|
|
}
|
|
|
|
m_bytesSettled += context->received;
|
|
if (context->task.kind == DownloadTask::AssetIndex)
|
|
expandAssetIndex(context->task.path);
|
|
|
|
scheduleProgress();
|
|
pump();
|
|
}
|
|
|
|
// Возвращает true, если задача поставлена на повтор, и false, если установка
|
|
// уже провалена.
|
|
bool VersionInstaller::retryOrFail(DownloadTask task, const QString &reason)
|
|
{
|
|
if (task.attempts + 1 >= kMaxAttempts) {
|
|
failInstall(Loc::text("common.error.downloadFailed").arg(task.label, reason));
|
|
return false;
|
|
}
|
|
|
|
++task.attempts;
|
|
const int delay = 400 * task.attempts;
|
|
QTimer::singleShot(delay, this, [this, task] {
|
|
if (!m_running || m_canceling)
|
|
return;
|
|
// В начало очереди: иначе повтор ждал бы за тысячами ресурсов.
|
|
m_queue.prepend(task);
|
|
pump();
|
|
});
|
|
return true;
|
|
}
|
|
|
|
void VersionInstaller::expandAssetIndex(const QString &indexPath)
|
|
{
|
|
QFile file(indexPath);
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
failInstall(Loc::text("version.error.assetIndexReadFailed")
|
|
.arg(QDir::toNativeSeparators(indexPath)));
|
|
return;
|
|
}
|
|
|
|
const QJsonObject root = QJsonDocument::fromJson(file.readAll()).object();
|
|
m_assetObjects = root.value(QStringLiteral("objects")).toObject();
|
|
m_assetsVirtual = root.value(QStringLiteral("virtual")).toBool();
|
|
m_assetsMapToResources = root.value(QStringLiteral("map_to_resources")).toBool();
|
|
|
|
setStage(Loc::text("version.progress.assets"));
|
|
|
|
qint64 actualTotal = 0;
|
|
for (auto it = m_assetObjects.constBegin(); it != m_assetObjects.constEnd(); ++it) {
|
|
const QJsonObject object = it.value().toObject();
|
|
const QString hash = object.value(QStringLiteral("hash")).toString();
|
|
if (!isSha1Hex(hash)) {
|
|
m_warnings << Loc::text("version.warning.skippedBadHash").arg(it.key());
|
|
continue;
|
|
}
|
|
|
|
const QString prefix = hash.left(2);
|
|
DownloadTask task;
|
|
task.kind = DownloadTask::AssetObject;
|
|
task.url = QUrl(kResourcesUrl + prefix + u'/' + hash);
|
|
task.path = m_gameDir + QStringLiteral("/assets/objects/") + prefix + u'/' + hash;
|
|
task.sha1 = hash;
|
|
task.size = object.value(QStringLiteral("size")).toInteger();
|
|
task.label = it.key();
|
|
actualTotal += task.size;
|
|
enqueue(std::move(task));
|
|
}
|
|
|
|
// enqueue уже прибавил вес ресурсов к итогу — снимаем заявленный заранее,
|
|
// чтобы он не учитывался дважды.
|
|
m_bytesTotal -= m_assetsDeclaredTotal;
|
|
m_assetsDeclaredTotal = actualTotal;
|
|
scheduleProgress();
|
|
}
|
|
|
|
// ── Завершение ─────────────────────────────────────────────────────────────
|
|
|
|
void VersionInstaller::afterDownloads()
|
|
{
|
|
const bool legacy = m_assetsVirtual || m_assetsMapToResources
|
|
|| m_version.assetsKind == QLatin1String("legacy")
|
|
|| m_version.assetsKind == QLatin1String("pre-1.6");
|
|
if (legacy && !m_assetObjects.isEmpty() && m_legacyCopies.isEmpty() && m_legacyIndex == 0) {
|
|
startLegacyCopy();
|
|
return;
|
|
}
|
|
complete();
|
|
}
|
|
|
|
void VersionInstaller::startLegacyCopy()
|
|
{
|
|
setStage(Loc::text("version.progress.preparingAssets"));
|
|
|
|
const QString targetRoot = m_assetsMapToResources
|
|
? m_gameDir + QStringLiteral("/resources/")
|
|
: m_gameDir + QStringLiteral("/assets/virtual/legacy/");
|
|
|
|
for (auto it = m_assetObjects.constBegin(); it != m_assetObjects.constEnd(); ++it) {
|
|
const QString name = it.key();
|
|
const QString hash = it.value().toObject().value(QStringLiteral("hash")).toString();
|
|
if (!isSha1Hex(hash) || !isSafeRelativePath(name))
|
|
continue;
|
|
m_legacyCopies.append({m_gameDir + QStringLiteral("/assets/objects/") + hash.left(2) + u'/'
|
|
+ hash,
|
|
targetRoot + name});
|
|
}
|
|
|
|
m_legacyIndex = 0;
|
|
if (m_legacyCopies.isEmpty()) {
|
|
complete();
|
|
return;
|
|
}
|
|
m_legacyTimer->start();
|
|
}
|
|
|
|
void VersionInstaller::legacyTick()
|
|
{
|
|
if (!m_running || m_canceling) {
|
|
m_legacyTimer->stop();
|
|
return;
|
|
}
|
|
|
|
const int end = std::min(m_legacyIndex + kLegacyCopiesPerTick, int(m_legacyCopies.size()));
|
|
for (; m_legacyIndex < end; ++m_legacyIndex) {
|
|
const auto &pair = m_legacyCopies.at(m_legacyIndex);
|
|
const QFileInfo source(pair.first);
|
|
const QFileInfo target(pair.second);
|
|
if (!source.exists())
|
|
continue;
|
|
if (target.exists() && target.size() == source.size())
|
|
continue;
|
|
|
|
QDir().mkpath(target.absolutePath());
|
|
QFile::remove(pair.second);
|
|
if (!QFile::copy(pair.first, pair.second))
|
|
m_warnings << Loc::text("version.error.assetPrepareFailed").arg(target.fileName());
|
|
}
|
|
|
|
m_currentLabel = Loc::text("version.progress.countOf").arg(m_legacyIndex).arg(m_legacyCopies.size());
|
|
scheduleProgress();
|
|
|
|
if (m_legacyIndex >= m_legacyCopies.size()) {
|
|
m_legacyTimer->stop();
|
|
complete();
|
|
}
|
|
}
|
|
|
|
void VersionInstaller::complete()
|
|
{
|
|
// Приёмка той же проверкой, которой пользуется запуск: успешная установка
|
|
// тогда по построению запускаема.
|
|
LaunchOptions probe;
|
|
probe.gameDir = m_gameDir;
|
|
probe.versionId = m_versionId;
|
|
const QStringList missing = GameLauncher::missingFiles(probe, m_version);
|
|
if (!missing.isEmpty()) {
|
|
failInstall(Loc::text("version.error.filesMissingAfterDownload")
|
|
.arg(missing.size())
|
|
.arg(missing.join(u'\n')));
|
|
return;
|
|
}
|
|
|
|
const QString id = m_versionId;
|
|
resetInstallState();
|
|
emit finished(id);
|
|
startNext();
|
|
}
|
|
|
|
void VersionInstaller::resetInstallState()
|
|
{
|
|
m_queue.clear();
|
|
m_active.clear();
|
|
m_assetObjects = {};
|
|
m_legacyCopies.clear();
|
|
m_legacyIndex = 0;
|
|
m_legacyTimer->stop();
|
|
m_versionId.clear();
|
|
m_stage.clear();
|
|
m_currentLabel.clear();
|
|
m_running = false;
|
|
m_progressDirty = false;
|
|
m_progressTimer->stop();
|
|
}
|
|
|
|
void VersionInstaller::failInstall(const QString &message)
|
|
{
|
|
const QString id = m_versionId;
|
|
QString text = message;
|
|
if (!m_warnings.isEmpty())
|
|
text += u'\n' + m_warnings.mid(0, 3).join(u'\n');
|
|
|
|
// Остальные версии из очереди уже некуда ставить — их пути могли зависеть
|
|
// от этой, да и пользователю нужен один внятный ответ.
|
|
m_pendingInstalls.clear();
|
|
m_inheritDepth = 0;
|
|
for (const auto &context : std::as_const(m_active)) {
|
|
if (context->reply)
|
|
context->reply->abort();
|
|
context->file->cancelWriting();
|
|
}
|
|
resetInstallState();
|
|
emit failed(id, text);
|
|
}
|
|
|
|
void VersionInstaller::abandonCurrent()
|
|
{
|
|
// Версия уступает очередь родителю: сигналов нет, установка продолжается.
|
|
m_queue.clear();
|
|
m_active.clear();
|
|
m_versionId.clear();
|
|
startNext();
|
|
}
|
|
|
|
void VersionInstaller::cancel()
|
|
{
|
|
if (!m_running)
|
|
return;
|
|
|
|
m_pendingInstalls.clear();
|
|
m_queue.clear();
|
|
m_legacyTimer->stop();
|
|
m_inheritDepth = 0;
|
|
m_canceling = true;
|
|
|
|
// abort() может доставить finished синхронно, а обработчик стирает элемент
|
|
// из m_active — поэтому обходим копию.
|
|
const auto active = m_active;
|
|
for (const auto &context : active) {
|
|
if (context->reply)
|
|
context->reply->abort();
|
|
}
|
|
// abort() мог довести отмену до конца прямо здесь — тогда m_canceling уже снят.
|
|
if (m_canceling && m_active.isEmpty())
|
|
finalizeCancel();
|
|
}
|
|
|
|
void VersionInstaller::finalizeCancel()
|
|
{
|
|
const QString id = m_versionId;
|
|
m_canceling = false;
|
|
resetInstallState();
|
|
emit canceled(id);
|
|
}
|