PrismLauncher/logic/forge/ForgeVersionList.cpp

450 lines
12 KiB
C++
Raw Normal View History

2015-02-02 22:25:30 +00:00
/* Copyright 2013-2015 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
2013-09-22 13:00:37 +01:00
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
2015-02-09 00:51:14 +00:00
#include "forge/ForgeVersionList.h"
#include "forge/ForgeVersion.h"
#include "net/NetJob.h"
#include "net/URLConstants.h"
#include "Env.h"
#include <QtNetwork>
#include <QtXml>
#include <QRegExp>
#include <QDebug>
2013-10-06 00:13:40 +01:00
2013-09-22 13:00:37 +01:00
ForgeVersionList::ForgeVersionList(QObject *parent) : BaseVersionList(parent)
{
}
Task *ForgeVersionList::getLoadTask()
{
return new ForgeListLoadTask(this);
}
bool ForgeVersionList::isLoaded()
{
return m_loaded;
}
const BaseVersionPtr ForgeVersionList::at(int i) const
{
return m_vlist.at(i);
}
int ForgeVersionList::count() const
{
return m_vlist.count();
}
2013-09-22 13:00:37 +01:00
int ForgeVersionList::columnCount(const QModelIndex &parent) const
{
return 1;
}
QVariant ForgeVersionList::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
2013-09-22 13:00:37 +01:00
if (index.row() > count())
return QVariant();
2013-09-22 13:00:37 +01:00
2013-10-06 00:13:40 +01:00
auto version = std::dynamic_pointer_cast<ForgeVersion>(m_vlist[index.row()]);
switch (role)
{
case VersionPointerRole:
return qVariantFromValue(m_vlist[index.row()]);
2013-09-22 13:00:37 +01:00
case VersionRole:
return version->name();
2013-09-22 13:00:37 +01:00
case VersionIdRole:
return version->descriptor();
2013-09-22 13:00:37 +01:00
case ParentGameVersionRole:
return version->mcver_sane;
2013-09-22 13:00:37 +01:00
case RecommendedRole:
return version->is_recommended;
2013-09-22 13:00:37 +01:00
case BranchRole:
return version->branch;
2013-09-22 13:00:37 +01:00
default:
return QVariant();
}
}
QList<BaseVersionList::ModelRoles> ForgeVersionList::providesRoles()
{
return {VersionPointerRole, VersionRole, VersionIdRole, ParentGameVersionRole, RecommendedRole, BranchRole};
}
BaseVersionPtr ForgeVersionList::getLatestStable() const
{
return BaseVersionPtr();
}
2013-09-22 13:00:37 +01:00
void ForgeVersionList::updateListData(QList<BaseVersionPtr> versions)
{
beginResetModel();
m_vlist = versions;
m_loaded = true;
endResetModel();
// NOW SORT!!
// sort();
}
void ForgeVersionList::sort()
{
// NO-OP for now
}
2013-09-22 13:00:37 +01:00
ForgeListLoadTask::ForgeListLoadTask(ForgeVersionList *vlist) : Task()
{
m_list = vlist;
}
void ForgeListLoadTask::executeTask()
{
2013-12-23 15:46:01 +00:00
setStatus(tr("Fetching Forge version lists..."));
auto job = new NetJob("Version index");
2013-09-22 13:00:37 +01:00
// we do not care if the version is stale or not.
auto forgeListEntry = ENV.metacache()->resolveEntry("minecraftforge", "list.json");
auto gradleForgeListEntry = ENV.metacache()->resolveEntry("minecraftforge", "json");
// verify by poking the server.
forgeListEntry->stale = true;
2013-12-22 23:12:03 +00:00
gradleForgeListEntry->stale = true;
job->addNetAction(listDownload = CacheDownload::make(QUrl(URLConstants::FORGE_LEGACY_URL),
forgeListEntry));
job->addNetAction(gradleListDownload = CacheDownload::make(
QUrl(URLConstants::FORGE_GRADLE_URL), gradleForgeListEntry));
2013-12-22 23:12:03 +00:00
connect(listDownload.get(), SIGNAL(failed(int)), SLOT(listFailed()));
connect(gradleListDownload.get(), SIGNAL(failed(int)), SLOT(gradleListFailed()));
listJob.reset(job);
2013-12-22 23:12:03 +00:00
connect(listJob.get(), SIGNAL(succeeded()), SLOT(listDownloaded()));
2013-10-06 00:13:40 +01:00
connect(listJob.get(), SIGNAL(progress(qint64, qint64)), SIGNAL(progress(qint64, qint64)));
listJob->start();
}
bool ForgeListLoadTask::abort()
2015-05-02 22:42:33 +01:00
{
return listJob->abort();
2015-05-02 22:42:33 +01:00
}
2013-12-22 23:12:03 +00:00
bool ForgeListLoadTask::parseForgeList(QList<BaseVersionPtr> &out)
{
2013-09-22 13:00:37 +01:00
QByteArray data;
{
2013-12-22 23:12:03 +00:00
auto dlJob = listDownload;
auto filename = std::dynamic_pointer_cast<CacheDownload>(dlJob)->getTargetFilepath();
2013-09-22 13:00:37 +01:00
QFile listFile(filename);
if (!listFile.open(QIODevice::ReadOnly))
2013-12-22 23:12:03 +00:00
{
return false;
}
2013-09-22 13:00:37 +01:00
data = listFile.readAll();
2013-12-22 23:12:03 +00:00
dlJob.reset();
2013-09-22 13:00:37 +01:00
}
QJsonParseError jsonError;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError);
2013-09-22 13:00:37 +01:00
if (jsonError.error != QJsonParseError::NoError)
{
emitFailed("Error parsing version list JSON:" + jsonError.errorString());
2013-12-22 23:12:03 +00:00
return false;
}
2013-09-22 13:00:37 +01:00
if (!jsonDoc.isObject())
{
2013-12-22 23:12:03 +00:00
emitFailed("Error parsing version list JSON: JSON root is not an object");
return false;
}
2013-09-22 13:00:37 +01:00
QJsonObject root = jsonDoc.object();
2013-09-22 13:00:37 +01:00
// Now, get the array of versions.
2013-09-22 13:00:37 +01:00
if (!root.value("builds").isArray())
{
2013-09-22 13:00:37 +01:00
emitFailed(
"Error parsing version list JSON: version list object is missing 'builds' array");
2013-12-22 23:12:03 +00:00
return false;
}
QJsonArray builds = root.value("builds").toArray();
2013-09-22 13:00:37 +01:00
for (int i = 0; i < builds.count(); i++)
{
// Load the version info.
2013-09-22 13:00:37 +01:00
if (!builds[i].isObject())
{
2013-09-22 13:00:37 +01:00
// FIXME: log this somewhere
continue;
}
QJsonObject obj = builds[i].toObject();
int build_nr = obj.value("build").toDouble(0);
2013-09-22 13:00:37 +01:00
if (!build_nr)
continue;
QJsonArray files = obj.value("files").toArray();
QString url, jobbuildver, mcver, buildtype, universal_filename;
QString changelog_url, installer_url;
QString installer_filename;
bool valid = false;
2013-09-22 13:00:37 +01:00
for (int j = 0; j < files.count(); j++)
{
2013-09-22 13:00:37 +01:00
if (!files[j].isObject())
2013-12-22 23:12:03 +00:00
{
continue;
2013-12-22 23:12:03 +00:00
}
QJsonObject file = files[j].toObject();
buildtype = file.value("buildtype").toString();
2013-09-22 13:00:37 +01:00
if ((buildtype == "client" || buildtype == "universal") && !valid)
{
mcver = file.value("mcver").toString();
url = file.value("url").toString();
jobbuildver = file.value("jobbuildver").toString();
int lastSlash = url.lastIndexOf('/');
universal_filename = url.mid(lastSlash + 1);
valid = true;
}
2013-09-22 13:00:37 +01:00
else if (buildtype == "changelog")
{
QString ext = file.value("ext").toString();
2013-09-22 13:00:37 +01:00
if (ext.isEmpty())
2013-12-22 23:12:03 +00:00
{
continue;
2013-12-22 23:12:03 +00:00
}
changelog_url = file.value("url").toString();
}
2013-09-22 13:00:37 +01:00
else if (buildtype == "installer")
{
installer_url = file.value("url").toString();
int lastSlash = installer_url.lastIndexOf('/');
2013-09-22 13:00:37 +01:00
installer_filename = installer_url.mid(lastSlash + 1);
}
}
2013-09-22 13:00:37 +01:00
if (valid)
{
// Now, we construct the version object and add it to the list.
2013-10-06 00:13:40 +01:00
std::shared_ptr<ForgeVersion> fVersion(new ForgeVersion());
fVersion->universal_url = url;
fVersion->changelog_url = changelog_url;
fVersion->installer_url = installer_url;
fVersion->jobbuildver = jobbuildver;
fVersion->mcver = fVersion->mcver_sane = mcver;
fVersion->installer_filename = installer_filename;
fVersion->universal_filename = universal_filename;
fVersion->m_buildnr = build_nr;
fVersion->type = ForgeVersion::Legacy;
2013-12-22 23:12:03 +00:00
out.append(fVersion);
}
}
return true;
}
bool ForgeListLoadTask::parseForgeGradleList(QList<BaseVersionPtr> &out)
{
QMap<int, std::shared_ptr<ForgeVersion>> lookup;
2013-12-22 23:12:03 +00:00
QByteArray data;
{
auto dlJob = gradleListDownload;
auto filename = std::dynamic_pointer_cast<CacheDownload>(dlJob)->getTargetFilepath();
2013-12-22 23:12:03 +00:00
QFile listFile(filename);
if (!listFile.open(QIODevice::ReadOnly))
{
return false;
}
data = listFile.readAll();
dlJob.reset();
}
QJsonParseError jsonError;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError);
if (jsonError.error != QJsonParseError::NoError)
{
emitFailed("Error parsing gradle version list JSON:" + jsonError.errorString());
return false;
}
if (!jsonDoc.isObject())
{
emitFailed("Error parsing gradle version list JSON: JSON root is not an object");
return false;
}
QJsonObject root = jsonDoc.object();
// we probably could hard code these, but it might still be worth doing it this way
const QString webpath = root.value("webpath").toString();
const QString artifact = root.value("artifact").toString();
QJsonObject numbers = root.value("number").toObject();
for (auto it = numbers.begin(); it != numbers.end(); ++it)
{
QJsonObject number = it.value().toObject();
std::shared_ptr<ForgeVersion> fVersion(new ForgeVersion());
fVersion->m_buildnr = number.value("build").toDouble();
if(fVersion->m_buildnr >= 953 && fVersion->m_buildnr <= 965)
{
qDebug() << fVersion->m_buildnr;
}
2013-12-22 23:12:03 +00:00
fVersion->jobbuildver = number.value("version").toString();
fVersion->branch = number.value("branch").toString("");
2013-12-22 23:12:03 +00:00
fVersion->mcver = number.value("mcversion").toString();
fVersion->universal_filename = "";
fVersion->installer_filename = "";
// HACK: here, we fix the minecraft version used by forge.
// HACK: this will inevitably break (later)
// FIXME: replace with a dictionary
fVersion->mcver_sane = fVersion->mcver;
fVersion->mcver_sane.replace("_pre", "-pre");
QString universal_filename, installer_filename;
2013-12-22 23:12:03 +00:00
QJsonArray files = number.value("files").toArray();
for (auto fIt = files.begin(); fIt != files.end(); ++fIt)
{
// TODO with gradle we also get checksums, use them
QJsonArray file = (*fIt).toArray();
if (file.size() < 3)
{
continue;
}
QString extension = file.at(0).toString();
QString part = file.at(1).toString();
QString checksum = file.at(2).toString();
// insane form of mcver is used here
QString longVersion = fVersion->mcver + "-" + fVersion->jobbuildver;
if (!fVersion->branch.isEmpty())
2013-12-22 23:12:03 +00:00
{
longVersion = longVersion + "-" + fVersion->branch;
2013-12-22 23:12:03 +00:00
}
QString filename = artifact + "-" + longVersion + "-" + part + "." + extension;
QString url = QString("%1/%2/%3")
.arg(webpath)
.arg(longVersion)
.arg(filename);
if (part == "installer")
2013-12-22 23:12:03 +00:00
{
fVersion->installer_url = url;
installer_filename = filename;
2013-12-22 23:12:03 +00:00
}
else if (part == "universal")
2013-12-22 23:12:03 +00:00
{
fVersion->universal_url = url;
universal_filename = filename;
2013-12-22 23:12:03 +00:00
}
else if (part == "changelog")
2013-12-22 23:12:03 +00:00
{
fVersion->changelog_url = url;
2013-12-22 23:12:03 +00:00
}
}
2013-12-22 23:12:03 +00:00
if (fVersion->installer_url.isEmpty() && fVersion->universal_url.isEmpty())
{
continue;
}
fVersion->universal_filename = universal_filename;
fVersion->installer_filename = installer_filename;
fVersion->type = ForgeVersion::Gradle;
2013-12-22 23:12:03 +00:00
out.append(fVersion);
lookup[fVersion->m_buildnr] = fVersion;
}
QJsonObject promos = root.value("promos").toObject();
for (auto it = promos.begin(); it != promos.end(); ++it)
{
QString key = it.key();
int build = it.value().toInt();
QRegularExpression regexp("^(?<mcversion>[0-9]+(.[0-9]+)*)-(?<label>[a-z]+)$");
auto match = regexp.match(key);
if(!match.hasMatch())
{
qDebug() << key << "doesn't match." << "build" << build;
continue;
}
QString label = match.captured("label");
if(label != "recommended")
{
continue;
}
QString mcversion = match.captured("mcversion");
qDebug() << "Forge build" << build << "is the" << label << "for Minecraft" << mcversion << QString("<%1>").arg(key);
lookup[build]->is_recommended = true;
2013-12-22 23:12:03 +00:00
}
return true;
}
void ForgeListLoadTask::listDownloaded()
{
QList<BaseVersionPtr> list;
bool ret = true;
if (!parseForgeList(list))
{
ret = false;
}
if (!parseForgeGradleList(list))
{
ret = false;
}
if (!ret)
{
return;
}
std::sort(list.begin(), list.end(), [](const BaseVersionPtr & l, const BaseVersionPtr & r)
{ return (*l > *r); });
2013-12-22 23:12:03 +00:00
m_list->updateListData(list);
2013-09-22 13:00:37 +01:00
emitSucceeded();
return;
}
2013-12-22 23:12:03 +00:00
void ForgeListLoadTask::listFailed()
{
auto reply = listDownload->m_reply;
if (reply)
{
qCritical() << "Getting forge version list failed: " << reply->errorString();
2013-12-22 23:12:03 +00:00
}
else
{
qCritical() << "Getting forge version list failed for reasons unknown.";
2013-12-22 23:12:03 +00:00
}
}
2014-05-04 23:10:59 +01:00
2013-12-22 23:12:03 +00:00
void ForgeListLoadTask::gradleListFailed()
{
auto reply = gradleListDownload->m_reply;
if (reply)
{
qCritical() << "Getting forge version list failed: " << reply->errorString();
2013-12-22 23:12:03 +00:00
}
else
{
qCritical() << "Getting forge version list failed for reasons unknown.";
2013-12-22 23:12:03 +00:00
}
}