pollymc/logic/BaseLauncher.cpp

618 lines
16 KiB
C++
Raw Normal View History

/* Copyright 2013-2015 MultiMC Contributors
*
* Authors: Orochimarufan <orochimarufan.x3@gmail.com>
*
* 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
*
* 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.
*/
#include "BaseLauncher.h"
#include "MessageLevel.h"
#include "MMCStrings.h"
#include "java/JavaChecker.h"
#include "tasks/Task.h"
#include <pathutils.h>
#include <QDebug>
#include <QDir>
#include <QEventLoop>
#include <QRegularExpression>
#include <QCoreApplication>
#include <QStandardPaths>
2015-06-16 01:38:13 +05:30
#define IBUS "@im=ibus"
void BaseLauncher::initializeEnvironment()
{
// prepare the process environment
QProcessEnvironment rawenv = QProcessEnvironment::systemEnvironment();
QStringList ignored =
{
"JAVA_ARGS",
"CLASSPATH",
"CONFIGPATH",
"JAVA_HOME",
"JRE_HOME",
"_JAVA_OPTIONS",
"JAVA_OPTIONS",
"JAVA_TOOL_OPTIONS"
};
for(auto key: rawenv.keys())
{
auto value = rawenv.value(key);
// filter out dangerous java crap
if(ignored.contains(key))
{
qDebug() << "Env: ignoring" << key << value;
continue;
}
// filter MultiMC-related things
if(key.startsWith("QT_"))
{
qDebug() << "Env: ignoring" << key << value;
continue;
}
#ifdef Q_OS_LINUX
// Do not pass LD_* variables to java. They were intended for MultiMC
if(key.startsWith("LD_"))
{
qDebug() << "Env: ignoring" << key << value;
continue;
}
// Strip IBus
// IBus is a Linux IME framework. For some reason, it breaks MC?
if (key == "XMODIFIERS" && value.contains(IBUS))
{
QString save = value;
value.replace(IBUS, "");
qDebug() << "Env: stripped" << IBUS << "from" << save << ":" << value;
}
if(key == "GAME_PRELOAD")
{
m_env.insert("LD_PRELOAD", value);
continue;
}
if(key == "GAME_LIBRARY_PATH")
{
m_env.insert("LD_LIBRARY_PATH", value);
continue;
}
#endif
qDebug() << "Env: " << key << value;
m_env.insert(key, value);
}
#ifdef Q_OS_LINUX
// HACK: Workaround for QTBUG42500
if(!m_env.contains("LD_LIBRARY_PATH"))
{
m_env.insert("LD_LIBRARY_PATH", "");
}
#endif
// export some infos
auto variables = getVariables();
for (auto it = variables.begin(); it != variables.end(); ++it)
{
m_env.insert(it.key(), it.value());
}
}
void BaseLauncher::init()
{
initializeEnvironment();
m_process.setProcessEnvironment(m_env);
connect(&m_process, &LoggedProcess::log, this, &BaseLauncher::on_log);
connect(&m_process, &LoggedProcess::stateChanged, this, &BaseLauncher::on_state);
m_prelaunchprocess.setProcessEnvironment(m_env);
connect(&m_prelaunchprocess, &LoggedProcess::log, this, &BaseLauncher::on_log);
connect(&m_prelaunchprocess, &LoggedProcess::stateChanged, this, &BaseLauncher::on_pre_state);
m_postlaunchprocess.setProcessEnvironment(m_env);
connect(&m_postlaunchprocess, &LoggedProcess::log, this, &BaseLauncher::on_log);
connect(&m_postlaunchprocess, &LoggedProcess::stateChanged, this, &BaseLauncher::on_post_state);
m_instance->setRunning(true);
}
std::shared_ptr<BaseLauncher> BaseLauncher::create(MinecraftInstancePtr inst)
{
std::shared_ptr<BaseLauncher> proc(new BaseLauncher(inst));
proc->init();
return proc;
}
BaseLauncher::BaseLauncher(InstancePtr instance): m_instance(instance)
{
}
QString BaseLauncher::censorPrivateInfo(QString in)
{
if (!m_session)
return in;
if (m_session->session != "-")
in.replace(m_session->session, "<SESSION ID>");
in.replace(m_session->access_token, "<ACCESS TOKEN>");
in.replace(m_session->client_token, "<CLIENT TOKEN>");
in.replace(m_session->uuid, "<PROFILE ID>");
in.replace(m_session->player_name, "<PROFILE NAME>");
auto i = m_session->u.properties.begin();
while (i != m_session->u.properties.end())
{
in.replace(i.value(), "<" + i.key().toUpper() + ">");
++i;
}
return in;
}
// console window
MessageLevel::Enum BaseLauncher::guessLevel(const QString &line, MessageLevel::Enum level)
{
QRegularExpression re("\\[(?<timestamp>[0-9:]+)\\] \\[[^/]+/(?<level>[^\\]]+)\\]");
auto match = re.match(line);
if(match.hasMatch())
{
// New style logs from log4j
QString timestamp = match.captured("timestamp");
QString levelStr = match.captured("level");
if(levelStr == "INFO")
level = MessageLevel::Message;
if(levelStr == "WARN")
level = MessageLevel::Warning;
if(levelStr == "ERROR")
level = MessageLevel::Error;
if(levelStr == "FATAL")
level = MessageLevel::Fatal;
if(levelStr == "TRACE" || levelStr == "DEBUG")
level = MessageLevel::Debug;
}
else
{
// Old style forge logs
if (line.contains("[INFO]") || line.contains("[CONFIG]") || line.contains("[FINE]") ||
line.contains("[FINER]") || line.contains("[FINEST]"))
level = MessageLevel::Message;
if (line.contains("[SEVERE]") || line.contains("[STDERR]"))
level = MessageLevel::Error;
if (line.contains("[WARNING]"))
level = MessageLevel::Warning;
if (line.contains("[DEBUG]"))
level = MessageLevel::Debug;
}
if (line.contains("overwriting existing"))
return MessageLevel::Fatal;
if (line.contains("Exception in thread") || line.contains(QRegularExpression("\\s+at ")))
return MessageLevel::Error;
return level;
}
QMap<QString, QString> BaseLauncher::getVariables() const
{
auto mcInstance = std::dynamic_pointer_cast<MinecraftInstance>(m_instance);
QMap<QString, QString> out;
out.insert("INST_NAME", mcInstance->name());
out.insert("INST_ID", mcInstance->id());
out.insert("INST_DIR", QDir(mcInstance->instanceRoot()).absolutePath());
out.insert("INST_MC_DIR", QDir(mcInstance->minecraftRoot()).absolutePath());
out.insert("INST_JAVA", mcInstance->settings()->get("JavaPath").toString());
out.insert("INST_JAVA_ARGS", javaArguments().join(' '));
return out;
}
QStringList BaseLauncher::javaArguments() const
{
QStringList args;
// custom args go first. we want to override them if we have our own here.
args.append(m_instance->extraArguments());
// OSX dock icon and name
#ifdef Q_OS_MAC
args << "-Xdock:icon=icon.png";
args << QString("-Xdock:name=\"%1\"").arg(m_instance->windowTitle());
#endif
// HACK: Stupid hack for Intel drivers. See: https://mojang.atlassian.net/browse/MCL-767
#ifdef Q_OS_WIN32
args << QString("-XX:HeapDumpPath=MojangTricksIntelDriversForPerformance_javaw.exe_"
"minecraft.exe.heapdump");
#endif
args << QString("-Xms%1m").arg(m_instance->settings()->get("MinMemAlloc").toInt());
args << QString("-Xmx%1m").arg(m_instance->settings()->get("MaxMemAlloc").toInt());
// No PermGen in newer java.
auto javaVersion = m_instance->settings()->get("JavaVersion");
if(Strings::naturalCompare(javaVersion.toString(), "1.8.0", Qt::CaseInsensitive) < 0)
{
auto permgen = m_instance->settings()->get("PermGen").toInt();
if (permgen != 64)
{
args << QString("-XX:PermSize=%1m").arg(permgen);
}
}
args << "-Duser.language=en";
if (!m_nativeFolder.isEmpty())
args << QString("-Djava.library.path=%1").arg(m_nativeFolder);
args << "-jar" << PathCombine(QCoreApplication::applicationDirPath(), "jars", "NewLaunch.jar");
return args;
}
void BaseLauncher::checkJava()
{
m_javaPath = m_instance->settings()->get("JavaPath").toString();
emit log("Java path is:\n" + m_javaPath + "\n\n");
auto realJavaPath = QStandardPaths::findExecutable(m_javaPath);
if (realJavaPath.isEmpty())
{
emit log(tr("The java binary \"%1\" couldn't be found. You may have to set up java "
"if Minecraft fails to launch.").arg(m_javaPath),
MessageLevel::Warning);
}
QFileInfo javaInfo(realJavaPath);
qlonglong javaUnixTime = javaInfo.lastModified().toMSecsSinceEpoch();
auto storedUnixTime = m_instance->settings()->get("JavaTimestamp").toLongLong();
this->m_javaUnixTime = javaUnixTime;
// if they are not the same, check!
if(javaUnixTime != storedUnixTime)
{
m_JavaChecker = std::make_shared<JavaChecker>();
bool successful = false;
QString errorLog;
QString version;
emit log(tr("Checking Java version..."), MessageLevel::MultiMC);
connect(m_JavaChecker.get(), &JavaChecker::checkFinished, this, &BaseLauncher::checkJavaFinished);
m_JavaChecker->m_path = realJavaPath;
m_JavaChecker->performCheck();
}
preLaunch();
}
void BaseLauncher::checkJavaFinished(JavaCheckResult result)
{
if(!result.valid)
{
// Error message displayed if java can't start
emit log(tr("Could not start java:"), MessageLevel::Error);
auto lines = result.errorLog.split('\n');
for(auto line: lines)
{
emit log(line, MessageLevel::Error);
}
emit log("\nCheck your MultiMC Java settings.", MessageLevel::MultiMC);
m_instance->cleanupAfterRun();
emit launch_failed(m_instance);
// not running, failed
m_instance->setRunning(false);
return;
}
emit log(tr("Java version is %1!\n").arg(result.javaVersion), MessageLevel::MultiMC);
m_instance->settings()->set("JavaVersion", result.javaVersion);
m_instance->settings()->set("JavaTimestamp", m_javaUnixTime);
preLaunch();
}
void BaseLauncher::executeTask()
{
printHeader();
emit log("Minecraft folder is:\n" + m_process.workingDirectory() + "\n\n");
checkJava();
}
void BaseLauncher::launch()
{
QString launchString("launch\n");
m_process.write(launchString.toUtf8());
}
void BaseLauncher::abort()
{
QString launchString("abort\n");
m_process.write(launchString.toUtf8());
}
void BaseLauncher::setWorkdir(QString path)
{
QDir mcDir(path);
m_process.setWorkingDirectory(mcDir.absolutePath());
m_prelaunchprocess.setWorkingDirectory(mcDir.absolutePath());
m_postlaunchprocess.setWorkingDirectory(mcDir.absolutePath());
}
void BaseLauncher::printHeader()
{
emit log(m_header);
}
void BaseLauncher::on_log(QStringList lines, MessageLevel::Enum level)
{
logOutput(lines, level);
}
void BaseLauncher::logOutput(const QStringList &lines, MessageLevel::Enum defaultLevel)
{
for (auto & line: lines)
{
logOutput(line, defaultLevel);
}
}
void BaseLauncher::logOutput(QString line, MessageLevel::Enum level)
{
// if the launcher part set a log level, use it
auto innerLevel = MessageLevel::fromLine(line);
if(innerLevel != MessageLevel::Unknown)
{
level = innerLevel;
}
// If the level is still undetermined, guess level
if (level == MessageLevel::StdErr || level == MessageLevel::StdOut || level == MessageLevel::Unknown)
{
level = this->guessLevel(line, level);
}
// censor private user info
line = censorPrivateInfo(line);
emit log(line, level);
}
void BaseLauncher::preLaunch()
{
QString prelaunch_cmd = m_instance->settings()->get("PreLaunchCommand").toString();
if (!prelaunch_cmd.isEmpty())
{
prelaunch_cmd = substituteVariables(prelaunch_cmd);
// Launch
emit log(tr("Running Pre-Launch command: %1").arg(prelaunch_cmd));
m_prelaunchprocess.start(prelaunch_cmd);
}
else
{
on_pre_state(LoggedProcess::Skipped);
}
}
void BaseLauncher::on_pre_state(LoggedProcess::State state)
{
switch(state)
{
case LoggedProcess::Aborted:
case LoggedProcess::Crashed:
case LoggedProcess::FailedToStart:
{
emit log(tr("Pre-Launch command failed with code %1.\n\n")
.arg(m_prelaunchprocess.exitCode()),
MessageLevel::Fatal);
m_instance->cleanupAfterRun();
emit prelaunch_failed(m_instance, m_prelaunchprocess.exitCode(), m_prelaunchprocess.exitStatus());
// not running, failed
m_instance->setRunning(false);
return;
}
case LoggedProcess::Finished:
{
emit log(tr("Pre-Launch command ran successfully.\n\n"));
}
case LoggedProcess::Skipped:
{
m_instance->reload();
updateInstance();
}
default:
break;
}
}
void BaseLauncher::updateInstance()
{
m_updateTask = m_instance->doUpdate();
if(m_updateTask)
{
connect(m_updateTask.get(), SIGNAL(finished()), this, SLOT(updateFinished()));
m_updateTask->start();
return;
}
makeReady();
}
void BaseLauncher::updateFinished()
{
if(m_updateTask->successful())
{
makeReady();
}
else
{
QString reason = tr("Instance update failed because: %1.\n\n").arg(m_updateTask->failReason());
emit log(reason, MessageLevel::Fatal);
m_instance->cleanupAfterRun();
emit update_failed(m_instance);
emitFailed(reason);
m_instance->setRunning(false);
}
}
void BaseLauncher::makeReady()
{
QStringList args = javaArguments();
QString allArgs = args.join(", ");
emit log("Java Arguments:\n[" + censorPrivateInfo(allArgs) + "]\n\n");
QString wrapperCommand = m_instance->settings()->get("WrapperCommand").toString();
if(!wrapperCommand.isEmpty())
{
auto realWrapperCommand = QStandardPaths::findExecutable(wrapperCommand);
if (realWrapperCommand.isEmpty())
{
emit log(tr("The wrapper command \"%1\" couldn't be found.").arg(wrapperCommand), MessageLevel::Warning);
m_instance->cleanupAfterRun();
emit launch_failed(m_instance);
m_instance->setRunning(false);
return;
}
emit log("Wrapper command is:\n" + wrapperCommand + "\n\n");
args.prepend(m_javaPath);
m_process.start(wrapperCommand, args);
}
else
{
m_process.start(m_javaPath, args);
}
// instantiate the launcher part
if (!m_process.waitForStarted())
{
//: Error message displayed if instace can't start
emit log(tr("Could not launch minecraft!"), MessageLevel::Error);
m_instance->cleanupAfterRun();
emit launch_failed(m_instance);
// not running, failed
m_instance->setRunning(false);
return;
}
emit log(tr("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC);
// send the launch script to the launcher part
m_process.write(launchScript.toUtf8());
emit readyForLaunch(shared_from_this());
}
void BaseLauncher::on_state(LoggedProcess::State state)
{
QProcess::ExitStatus estat = QProcess::NormalExit;
switch(state)
{
case LoggedProcess::Aborted:
case LoggedProcess::Crashed:
case LoggedProcess::FailedToStart:
estat = QProcess::CrashExit;
case LoggedProcess::Finished:
{
auto exitCode = m_process.exitCode();
m_postlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(exitCode));
// run post-exit
postLaunch();
m_instance->cleanupAfterRun();
// no longer running...
m_instance->setRunning(false);
emit ended(m_instance, exitCode, estat);
break;
}
case LoggedProcess::Skipped:
qWarning() << "Illegal game state: Skipped";
break;
case LoggedProcess::Running:
m_instance->setLastLaunch();
break;
default:
break;
}
}
void BaseLauncher::on_post_state(LoggedProcess::State state)
{
switch(state)
{
case LoggedProcess::Aborted:
case LoggedProcess::Crashed:
case LoggedProcess::FailedToStart:
case LoggedProcess::Finished:
case LoggedProcess::Skipped:
{
}
default:
break;
}
}
void BaseLauncher::killProcess()
{
killed = true;
if (m_prelaunchprocess.state() == LoggedProcess::Running)
{
m_prelaunchprocess.kill();
}
else if(m_process.state() == LoggedProcess::Running)
{
m_process.kill();
}
else if(m_postlaunchprocess.state() == LoggedProcess::Running)
{
m_postlaunchprocess.kill();
}
}
void BaseLauncher::postLaunch()
{
QString postlaunch_cmd = m_instance->settings()->get("PostExitCommand").toString();
if (!postlaunch_cmd.isEmpty())
{
postlaunch_cmd = substituteVariables(postlaunch_cmd);
emit log(tr("Running Post-Launch command: %1").arg(postlaunch_cmd));
m_postlaunchprocess.start(postlaunch_cmd);
if (m_postlaunchprocess.exitStatus() != QProcess::NormalExit)
{
emit log(tr("Post-Launch command failed with code %1.\n\n")
.arg(m_postlaunchprocess.exitCode()),
MessageLevel::Error);
emit postlaunch_failed(m_instance, m_postlaunchprocess.exitCode(),
m_postlaunchprocess.exitStatus());
// not running, failed
m_instance->setRunning(false);
}
else
emit log(tr("Post-Launch command ran successfully.\n\n"));
}
}
QString BaseLauncher::substituteVariables(const QString &cmd) const
{
QString out = cmd;
auto variables = getVariables();
for (auto it = variables.begin(); it != variables.end(); ++it)
{
out.replace("$" + it.key(), it.value());
}
auto env = QProcessEnvironment::systemEnvironment();
for (auto var : env.keys())
{
out.replace("$" + var, env.value(var));
}
return out;
}
qint64 BaseLauncher::pid()
{
#ifdef Q_OS_WIN
struct _PROCESS_INFORMATION *procinfo = m_process.pid();
return procinfo->dwProcessId;
#else
return m_process.pid();
#endif
}