2023-03-03 01:18:41 +05:30
|
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
/*
|
|
|
|
* Prism Launcher - Minecraft Launcher
|
|
|
|
* Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me>
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, version 3.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "ModrinthPackExportTask.h"
|
2023-03-03 20:30:07 +05:30
|
|
|
|
2023-03-18 17:51:13 +05:30
|
|
|
#include <QCryptographicHash>
|
2023-03-03 20:30:07 +05:30
|
|
|
#include <QFileInfo>
|
2023-03-03 01:18:41 +05:30
|
|
|
#include <QMessageBox>
|
2023-04-07 00:28:09 +05:30
|
|
|
#include <QtConcurrentRun>
|
2023-03-03 20:30:07 +05:30
|
|
|
#include "Json.h"
|
2023-03-03 01:18:41 +05:30
|
|
|
#include "MMCZip.h"
|
|
|
|
#include "minecraft/PackProfile.h"
|
2023-04-06 23:48:36 +05:30
|
|
|
#include "minecraft/mod/ModFolderModel.h"
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-04-06 23:48:36 +05:30
|
|
|
const QStringList ModrinthPackExportTask::PREFIXES({ "mods", "coremods", "resourcepacks", "texturepacks", "shaderpacks" });
|
2023-03-04 15:54:25 +05:30
|
|
|
|
2023-03-03 01:18:41 +05:30
|
|
|
ModrinthPackExportTask::ModrinthPackExportTask(const QString& name,
|
|
|
|
const QString& version,
|
|
|
|
const QString& summary,
|
|
|
|
InstancePtr instance,
|
|
|
|
const QString& output,
|
|
|
|
MMCZip::FilterFunction filter)
|
2023-04-06 23:54:19 +05:30
|
|
|
: name(name)
|
|
|
|
, version(version)
|
|
|
|
, summary(summary)
|
|
|
|
, instance(instance)
|
|
|
|
, mcInstance(dynamic_cast<const MinecraftInstance*>(instance.get()))
|
|
|
|
, output(output)
|
|
|
|
, filter(filter)
|
2023-03-03 01:18:41 +05:30
|
|
|
{}
|
|
|
|
|
|
|
|
void ModrinthPackExportTask::executeTask()
|
|
|
|
{
|
2023-03-03 20:30:07 +05:30
|
|
|
setStatus(tr("Searching for files..."));
|
2023-03-04 15:54:25 +05:30
|
|
|
setProgress(0, 0);
|
|
|
|
collectFiles();
|
2023-03-04 16:07:52 +05:30
|
|
|
}
|
|
|
|
|
2023-03-05 01:25:38 +05:30
|
|
|
bool ModrinthPackExportTask::abort()
|
|
|
|
{
|
2023-03-06 22:52:20 +05:30
|
|
|
if (task != nullptr) {
|
|
|
|
if (!task->abort())
|
|
|
|
return false;
|
|
|
|
|
2023-03-04 16:37:07 +05:30
|
|
|
task = nullptr;
|
2023-03-18 17:51:13 +05:30
|
|
|
emitAborted();
|
2023-03-04 16:37:07 +05:30
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2023-03-06 22:52:20 +05:30
|
|
|
pendingAbort = true;
|
|
|
|
return true;
|
2023-03-04 15:54:25 +05:30
|
|
|
}
|
2023-03-03 20:30:07 +05:30
|
|
|
|
2023-03-04 15:54:25 +05:30
|
|
|
void ModrinthPackExportTask::collectFiles()
|
|
|
|
{
|
|
|
|
files.clear();
|
2023-03-03 20:30:07 +05:30
|
|
|
if (!MMCZip::collectFileListRecursively(instance->gameRoot(), nullptr, &files, filter)) {
|
2023-04-07 00:29:15 +05:30
|
|
|
emitFailed(tr("Could not search for files"));
|
2023-03-03 20:30:07 +05:30
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-05 01:25:38 +05:30
|
|
|
pendingHashes.clear();
|
|
|
|
resolvedFiles.clear();
|
2023-03-03 20:30:07 +05:30
|
|
|
|
2023-04-06 23:54:19 +05:30
|
|
|
if (mcInstance) {
|
|
|
|
mcInstance->loaderModList()->update();
|
|
|
|
connect(mcInstance->loaderModList().get(), &ModFolderModel::updateFinished, this, &ModrinthPackExportTask::collectHashes);
|
|
|
|
} else
|
|
|
|
collectHashes();
|
2023-04-06 23:48:36 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void ModrinthPackExportTask::collectHashes()
|
|
|
|
{
|
2023-03-04 15:54:25 +05:30
|
|
|
QDir mc(instance->gameRoot());
|
2023-03-03 20:30:07 +05:30
|
|
|
for (QFileInfo file : files) {
|
|
|
|
QString relative = mc.relativeFilePath(file.absoluteFilePath());
|
|
|
|
// require sensible file types
|
|
|
|
if (!(relative.endsWith(".zip") || relative.endsWith(".jar") || relative.endsWith(".litemod")))
|
|
|
|
continue;
|
|
|
|
|
2023-03-04 15:54:25 +05:30
|
|
|
if (!std::any_of(PREFIXES.begin(), PREFIXES.end(),
|
2023-03-03 20:30:07 +05:30
|
|
|
[&relative](const QString& prefix) { return relative.startsWith(prefix + QDir::separator()); }))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
QCryptographicHash hash(QCryptographicHash::Algorithm::Sha512);
|
|
|
|
|
|
|
|
QFile openFile(file.absoluteFilePath());
|
|
|
|
if (!openFile.open(QFile::ReadOnly)) {
|
|
|
|
qWarning() << "Could not open" << file << "for hashing";
|
|
|
|
continue;
|
2023-03-03 16:44:57 +05:30
|
|
|
}
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-04-06 23:48:36 +05:30
|
|
|
QByteArray data = openFile.readAll();
|
|
|
|
if (openFile.error() != QFileDevice::NoError) {
|
|
|
|
qWarning() << "Could not read" << file;
|
2023-03-03 20:30:07 +05:30
|
|
|
continue;
|
|
|
|
}
|
2023-04-06 23:48:36 +05:30
|
|
|
hash.addData(data);
|
|
|
|
|
2023-04-06 23:54:19 +05:30
|
|
|
auto allMods = mcInstance->loaderModList()->allMods();
|
2023-04-06 23:48:36 +05:30
|
|
|
if (auto modIter = std::find_if(allMods.begin(), allMods.end(), [&file](Mod* mod) { return mod->fileinfo() == file; });
|
|
|
|
modIter != allMods.end()) {
|
|
|
|
Mod* mod = *modIter;
|
|
|
|
if (mod->metadata() != nullptr) {
|
|
|
|
QUrl& url = mod->metadata()->url;
|
|
|
|
// most likely some of these may be from curseforge
|
|
|
|
if (!url.isEmpty() && BuildConfig.MODRINTH_MRPACK_HOSTS.contains(url.host())) {
|
|
|
|
qDebug() << "Resolving" << relative << "from index";
|
|
|
|
|
|
|
|
// we've already read it
|
|
|
|
// let's go back!
|
|
|
|
openFile.seek(openFile.size());
|
|
|
|
|
|
|
|
QCryptographicHash hash2(QCryptographicHash::Algorithm::Sha1);
|
|
|
|
hash2.addData(data);
|
|
|
|
|
|
|
|
ResolvedFile file{ hash2.result().toHex(), hash.result().toHex(), url.toString(), openFile.size() };
|
|
|
|
resolvedFiles[relative] = file;
|
|
|
|
|
|
|
|
// nice! we've managed to resolve based on local metadata!
|
|
|
|
// no need to enqueue it
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-03-03 20:30:07 +05:30
|
|
|
|
2023-04-06 23:48:36 +05:30
|
|
|
qDebug() << "Enqueueing" << relative << "for Modrinth query";
|
2023-03-05 01:25:38 +05:30
|
|
|
pendingHashes[relative] = hash.result().toHex();
|
2023-03-03 20:30:07 +05:30
|
|
|
}
|
2023-04-06 23:48:36 +05:30
|
|
|
|
|
|
|
makeApiRequest();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModrinthPackExportTask::makeApiRequest()
|
|
|
|
{
|
|
|
|
if (pendingHashes.isEmpty())
|
|
|
|
buildZip();
|
|
|
|
else {
|
|
|
|
QByteArray* response = new QByteArray;
|
|
|
|
task = api.currentVersions(pendingHashes.values(), "sha512", response);
|
|
|
|
connect(task.get(), &NetJob::succeeded, [this, response]() { parseApiResponse(response); });
|
|
|
|
connect(task.get(), &NetJob::failed, this, &ModrinthPackExportTask::emitFailed);
|
|
|
|
task->start();
|
|
|
|
}
|
2023-03-04 15:54:25 +05:30
|
|
|
}
|
2023-03-03 20:30:07 +05:30
|
|
|
|
2023-03-04 15:54:25 +05:30
|
|
|
void ModrinthPackExportTask::parseApiResponse(QByteArray* response)
|
|
|
|
{
|
2023-03-06 22:52:20 +05:30
|
|
|
task = nullptr;
|
|
|
|
|
2023-03-04 15:54:25 +05:30
|
|
|
try {
|
2023-04-07 15:33:11 +05:30
|
|
|
const QJsonDocument doc = Json::requireDocument(*response);
|
2023-03-04 15:54:25 +05:30
|
|
|
|
2023-03-05 01:25:38 +05:30
|
|
|
QMapIterator<QString, QString> iterator(pendingHashes);
|
2023-03-04 15:54:25 +05:30
|
|
|
while (iterator.hasNext()) {
|
|
|
|
iterator.next();
|
|
|
|
|
|
|
|
QJsonObject obj = doc[iterator.value()].toObject();
|
|
|
|
if (obj.isEmpty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
QJsonArray files = obj["files"].toArray();
|
|
|
|
if (auto fileIter = std::find_if(files.begin(), files.end(),
|
|
|
|
[&iterator](const QJsonValue& file) { return file["hashes"]["sha512"] == iterator.value(); });
|
|
|
|
fileIter != files.end()) {
|
|
|
|
// map the file to the url
|
2023-03-05 01:25:38 +05:30
|
|
|
resolvedFiles[iterator.key()] =
|
|
|
|
ResolvedFile{ fileIter->toObject()["hashes"].toObject()["sha1"].toString(), iterator.value(),
|
|
|
|
fileIter->toObject()["url"].toString(), fileIter->toObject()["size"].toInt() };
|
2023-03-03 20:30:07 +05:30
|
|
|
}
|
|
|
|
}
|
2023-03-04 15:54:25 +05:30
|
|
|
} catch (Json::JsonException& e) {
|
|
|
|
qWarning() << "Failed to parse versions response" << e.what();
|
|
|
|
}
|
2023-03-05 01:25:38 +05:30
|
|
|
pendingHashes.clear();
|
2023-04-07 15:33:11 +05:30
|
|
|
buildZip();
|
2023-03-04 15:54:25 +05:30
|
|
|
}
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-03-05 01:25:38 +05:30
|
|
|
void ModrinthPackExportTask::buildZip()
|
2023-03-04 15:54:25 +05:30
|
|
|
{
|
2023-04-07 00:28:09 +05:30
|
|
|
static_cast<void>(QtConcurrent::run(QThreadPool::globalInstance(), [this]() {
|
2023-03-06 22:52:20 +05:30
|
|
|
setStatus("Adding files...");
|
|
|
|
QuaZip zip(output);
|
|
|
|
if (!zip.open(QuaZip::mdCreate)) {
|
|
|
|
QFile::remove(output);
|
|
|
|
emitFailed(tr("Could not create file"));
|
|
|
|
return;
|
|
|
|
}
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-03-06 22:52:20 +05:30
|
|
|
if (pendingAbort) {
|
2023-03-20 02:56:25 +05:30
|
|
|
QMetaObject::invokeMethod(this, &ModrinthPackExportTask::emitAborted, Qt::QueuedConnection);
|
2023-03-06 22:52:20 +05:30
|
|
|
return;
|
|
|
|
}
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-03-06 22:52:20 +05:30
|
|
|
QuaZipFile indexFile(&zip);
|
|
|
|
if (!indexFile.open(QIODevice::WriteOnly, QuaZipNewInfo("modrinth.index.json"))) {
|
|
|
|
QFile::remove(output);
|
2023-03-18 17:51:13 +05:30
|
|
|
QMetaObject::invokeMethod(
|
|
|
|
this, [this]() { emitFailed(tr("Could not create index")); }, Qt::QueuedConnection);
|
2023-03-06 22:52:20 +05:30
|
|
|
return;
|
|
|
|
}
|
|
|
|
indexFile.write(generateIndex());
|
|
|
|
|
|
|
|
QDir mc(instance->gameRoot());
|
|
|
|
size_t i = 0;
|
|
|
|
for (const QFileInfo& file : files) {
|
|
|
|
if (pendingAbort) {
|
|
|
|
QFile::remove(output);
|
2023-03-20 02:56:25 +05:30
|
|
|
QMetaObject::invokeMethod(this, &ModrinthPackExportTask::emitAborted, Qt::QueuedConnection);
|
2023-03-06 22:52:20 +05:30
|
|
|
return;
|
|
|
|
}
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-03-06 22:52:20 +05:30
|
|
|
setProgress(i, files.length());
|
|
|
|
QString relative = mc.relativeFilePath(file.absoluteFilePath());
|
2023-03-28 18:52:28 +05:30
|
|
|
if (!resolvedFiles.contains(relative) && !JlCompress::compressFile(&zip, file.absoluteFilePath(), "overrides/" + relative)) {
|
|
|
|
QFile::remove(output);
|
|
|
|
QMetaObject::invokeMethod(
|
2023-04-06 23:48:36 +05:30
|
|
|
this, [this, relative]() { emitFailed(tr("Could not read and compress %1").arg(relative)); }, Qt::QueuedConnection);
|
2023-03-28 18:52:28 +05:30
|
|
|
return;
|
|
|
|
}
|
2023-03-06 22:52:20 +05:30
|
|
|
i++;
|
|
|
|
}
|
2023-03-03 16:44:57 +05:30
|
|
|
|
2023-03-06 22:52:20 +05:30
|
|
|
zip.close();
|
|
|
|
|
|
|
|
if (zip.getZipError() != 0) {
|
|
|
|
QFile::remove(output);
|
2023-03-18 17:51:13 +05:30
|
|
|
QMetaObject::invokeMethod(
|
|
|
|
this, [this]() { emitFailed(tr("A zip error occurred")); }, Qt::QueuedConnection);
|
2023-03-06 22:52:20 +05:30
|
|
|
return;
|
|
|
|
}
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-03-20 02:56:25 +05:30
|
|
|
QMetaObject::invokeMethod(this, &ModrinthPackExportTask::emitSucceeded, Qt::QueuedConnection);
|
2023-04-07 00:28:09 +05:30
|
|
|
}));
|
2023-03-03 01:18:41 +05:30
|
|
|
}
|
|
|
|
|
2023-03-05 01:25:38 +05:30
|
|
|
QByteArray ModrinthPackExportTask::generateIndex()
|
2023-03-03 01:18:41 +05:30
|
|
|
{
|
|
|
|
QJsonObject obj;
|
|
|
|
obj["formatVersion"] = 1;
|
|
|
|
obj["game"] = "minecraft";
|
|
|
|
obj["name"] = name;
|
|
|
|
obj["versionId"] = version;
|
2023-03-18 19:31:41 +05:30
|
|
|
if (!summary.isEmpty())
|
|
|
|
obj["summary"] = summary;
|
2023-03-03 01:18:41 +05:30
|
|
|
|
|
|
|
MinecraftInstance* mc = dynamic_cast<MinecraftInstance*>(instance.get());
|
|
|
|
if (mc) {
|
|
|
|
auto profile = mc->getPackProfile();
|
2023-03-03 16:54:10 +05:30
|
|
|
// collect all supported components
|
2023-04-06 23:48:36 +05:30
|
|
|
ComponentPtr minecraft = profile->getComponent("net.minecraft");
|
|
|
|
ComponentPtr quilt = profile->getComponent("org.quiltmc.quilt-loader");
|
|
|
|
ComponentPtr fabric = profile->getComponent("net.fabricmc.fabric-loader");
|
|
|
|
ComponentPtr forge = profile->getComponent("net.minecraftforge");
|
2023-03-03 01:18:41 +05:30
|
|
|
|
2023-03-03 16:54:10 +05:30
|
|
|
// convert all available components to mrpack dependencies
|
2023-03-03 01:18:41 +05:30
|
|
|
QJsonObject dependencies;
|
2023-03-03 16:54:10 +05:30
|
|
|
if (minecraft != nullptr)
|
|
|
|
dependencies["minecraft"] = minecraft->m_version;
|
|
|
|
if (quilt != nullptr)
|
|
|
|
dependencies["quilt-loader"] = quilt->m_version;
|
|
|
|
if (fabric != nullptr)
|
|
|
|
dependencies["fabric-loader"] = fabric->m_version;
|
|
|
|
if (forge != nullptr)
|
|
|
|
dependencies["forge"] = forge->m_version;
|
2023-03-20 02:56:25 +05:30
|
|
|
|
2023-03-03 01:18:41 +05:30
|
|
|
obj["dependencies"] = dependencies;
|
|
|
|
}
|
|
|
|
|
2023-03-03 20:30:07 +05:30
|
|
|
QJsonArray files;
|
2023-03-04 15:54:25 +05:30
|
|
|
QMapIterator<QString, ResolvedFile> iterator(resolvedFiles);
|
2023-03-03 20:30:07 +05:30
|
|
|
while (iterator.hasNext()) {
|
|
|
|
iterator.next();
|
|
|
|
|
|
|
|
const ResolvedFile& value = iterator.value();
|
|
|
|
|
|
|
|
QJsonObject file;
|
2023-03-20 02:55:12 +05:30
|
|
|
QString path = iterator.key();
|
|
|
|
path.replace(QDir::separator(), "/");
|
|
|
|
file["path"] = path;
|
2023-03-03 20:30:07 +05:30
|
|
|
file["downloads"] = QJsonArray({ iterator.value().url });
|
|
|
|
|
|
|
|
QJsonObject hashes;
|
|
|
|
hashes["sha1"] = value.sha1;
|
|
|
|
hashes["sha512"] = value.sha512;
|
2023-04-07 00:28:09 +05:30
|
|
|
|
2023-03-03 20:30:07 +05:30
|
|
|
file["hashes"] = hashes;
|
|
|
|
file["fileSize"] = value.size;
|
|
|
|
|
|
|
|
files << file;
|
|
|
|
}
|
|
|
|
obj["files"] = files;
|
|
|
|
|
2023-03-03 01:18:41 +05:30
|
|
|
return QJsonDocument(obj).toJson(QJsonDocument::Compact);
|
|
|
|
}
|