summaryrefslogtreecommitdiffstats
path: root/api/logic/launch
diff options
context:
space:
mode:
Diffstat (limited to 'api/logic/launch')
-rw-r--r--api/logic/launch/LaunchStep.cpp27
-rw-r--r--api/logic/launch/LaunchStep.h48
-rw-r--r--api/logic/launch/LaunchTask.cpp228
-rw-r--r--api/logic/launch/LaunchTask.h122
-rw-r--r--api/logic/launch/LoggedProcess.cpp163
-rw-r--r--api/logic/launch/LoggedProcess.h76
-rw-r--r--api/logic/launch/MessageLevel.cpp36
-rw-r--r--api/logic/launch/MessageLevel.h28
-rw-r--r--api/logic/launch/steps/CheckJava.cpp92
-rw-r--r--api/logic/launch/steps/CheckJava.h41
-rw-r--r--api/logic/launch/steps/LaunchMinecraft.cpp155
-rw-r--r--api/logic/launch/steps/LaunchMinecraft.h48
-rw-r--r--api/logic/launch/steps/ModMinecraftJar.cpp44
-rw-r--r--api/logic/launch/steps/ModMinecraftJar.h39
-rw-r--r--api/logic/launch/steps/PostLaunchCommand.cpp84
-rw-r--r--api/logic/launch/steps/PostLaunchCommand.h39
-rw-r--r--api/logic/launch/steps/PreLaunchCommand.cpp85
-rw-r--r--api/logic/launch/steps/PreLaunchCommand.h39
-rw-r--r--api/logic/launch/steps/TextPrint.cpp29
-rw-r--r--api/logic/launch/steps/TextPrint.h43
-rw-r--r--api/logic/launch/steps/Update.cpp50
-rw-r--r--api/logic/launch/steps/Update.h41
22 files changed, 1557 insertions, 0 deletions
diff --git a/api/logic/launch/LaunchStep.cpp b/api/logic/launch/LaunchStep.cpp
new file mode 100644
index 00000000..3078043b
--- /dev/null
+++ b/api/logic/launch/LaunchStep.cpp
@@ -0,0 +1,27 @@
+/* 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
+ *
+ * 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 "LaunchStep.h"
+#include "LaunchTask.h"
+
+void LaunchStep::bind(LaunchTask *parent)
+{
+ m_parent = parent;
+ connect(this, &LaunchStep::readyForLaunch, parent, &LaunchTask::onReadyForLaunch);
+ connect(this, &LaunchStep::logLine, parent, &LaunchTask::onLogLine);
+ connect(this, &LaunchStep::logLines, parent, &LaunchTask::onLogLines);
+ connect(this, &LaunchStep::finished, parent, &LaunchTask::onStepFinished);
+ connect(this, &LaunchStep::progressReportingRequest, parent, &LaunchTask::onProgressReportingRequested);
+}
diff --git a/api/logic/launch/LaunchStep.h b/api/logic/launch/LaunchStep.h
new file mode 100644
index 00000000..ea472c0d
--- /dev/null
+++ b/api/logic/launch/LaunchStep.h
@@ -0,0 +1,48 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "tasks/Task.h"
+#include "MessageLevel.h"
+
+#include <QStringList>
+
+class LaunchTask;
+class LaunchStep: public Task
+{
+ Q_OBJECT
+public: /* methods */
+ explicit LaunchStep(LaunchTask *parent):Task(nullptr), m_parent(parent)
+ {
+ bind(parent);
+ };
+ virtual ~LaunchStep() {};
+
+protected: /* methods */
+ virtual void bind(LaunchTask *parent);
+
+signals:
+ void logLines(QStringList lines, MessageLevel::Enum level);
+ void logLine(QString line, MessageLevel::Enum level);
+ void readyForLaunch();
+ void progressReportingRequest();
+
+public slots:
+ virtual void proceed() {};
+
+protected: /* data */
+ LaunchTask *m_parent;
+}; \ No newline at end of file
diff --git a/api/logic/launch/LaunchTask.cpp b/api/logic/launch/LaunchTask.cpp
new file mode 100644
index 00000000..5b7ff182
--- /dev/null
+++ b/api/logic/launch/LaunchTask.cpp
@@ -0,0 +1,228 @@
+/* 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 "launch/LaunchTask.h"
+#include "MessageLevel.h"
+#include "MMCStrings.h"
+#include "java/JavaChecker.h"
+#include "tasks/Task.h"
+#include <QDebug>
+#include <QDir>
+#include <QEventLoop>
+#include <QRegularExpression>
+#include <QCoreApplication>
+#include <QStandardPaths>
+#include <assert.h>
+
+void LaunchTask::init()
+{
+ m_instance->setRunning(true);
+}
+
+std::shared_ptr<LaunchTask> LaunchTask::create(InstancePtr inst)
+{
+ std::shared_ptr<LaunchTask> proc(new LaunchTask(inst));
+ proc->init();
+ return proc;
+}
+
+LaunchTask::LaunchTask(InstancePtr instance): m_instance(instance)
+{
+}
+
+void LaunchTask::appendStep(std::shared_ptr<LaunchStep> step)
+{
+ m_steps.append(step);
+}
+
+void LaunchTask::prependStep(std::shared_ptr<LaunchStep> step)
+{
+ m_steps.prepend(step);
+}
+
+void LaunchTask::executeTask()
+{
+ if(!m_steps.size())
+ {
+ state = LaunchTask::Finished;
+ emitSucceeded();
+ }
+ state = LaunchTask::Running;
+ onStepFinished();
+}
+
+void LaunchTask::onReadyForLaunch()
+{
+ state = LaunchTask::Waiting;
+ emit readyForLaunch();
+}
+
+void LaunchTask::onStepFinished()
+{
+ // initial -> just start the first step
+ if(currentStep == -1)
+ {
+ currentStep ++;
+ m_steps[currentStep]->start();
+ return;
+ }
+
+ auto step = m_steps[currentStep];
+ if(step->successful())
+ {
+ // end?
+ if(currentStep == m_steps.size() - 1)
+ {
+ emitSucceeded();
+ }
+ else
+ {
+ currentStep ++;
+ step = m_steps[currentStep];
+ step->start();
+ }
+ }
+ else
+ {
+ emitFailed(step->failReason());
+ }
+}
+
+void LaunchTask::onProgressReportingRequested()
+{
+ state = LaunchTask::Waiting;
+ emit requestProgress(m_steps[currentStep].get());
+}
+
+void LaunchTask::setCensorFilter(QMap<QString, QString> filter)
+{
+ m_censorFilter = filter;
+}
+
+QString LaunchTask::censorPrivateInfo(QString in)
+{
+ auto iter = m_censorFilter.begin();
+ while (iter != m_censorFilter.end())
+ {
+ in.replace(iter.key(), iter.value());
+ iter++;
+ }
+ return in;
+}
+
+void LaunchTask::proceed()
+{
+ if(state != LaunchTask::Waiting)
+ {
+ return;
+ }
+ m_steps[currentStep]->proceed();
+}
+
+bool LaunchTask::abort()
+{
+ switch(state)
+ {
+ case LaunchTask::Aborted:
+ case LaunchTask::Failed:
+ case LaunchTask::Finished:
+ return true;
+ case LaunchTask::NotStarted:
+ {
+ state = LaunchTask::Aborted;
+ emitFailed("Aborted");
+ return true;
+ }
+ case LaunchTask::Running:
+ case LaunchTask::Waiting:
+ {
+ auto step = m_steps[currentStep];
+ if(!step->canAbort())
+ {
+ return false;
+ }
+ if(step->abort())
+ {
+ state = LaunchTask::Aborted;
+ return true;
+ }
+ }
+ default:
+ break;
+ }
+ return false;
+}
+
+void LaunchTask::onLogLines(const QStringList &lines, MessageLevel::Enum defaultLevel)
+{
+ for (auto & line: lines)
+ {
+ onLogLine(line, defaultLevel);
+ }
+}
+
+void LaunchTask::onLogLine(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 = m_instance->guessLevel(line, level);
+ }
+
+ // censor private user info
+ line = censorPrivateInfo(line);
+
+ emit log(line, level);
+}
+
+void LaunchTask::emitSucceeded()
+{
+ m_instance->cleanupAfterRun();
+ m_instance->setRunning(false);
+ Task::emitSucceeded();
+}
+
+void LaunchTask::emitFailed(QString reason)
+{
+ m_instance->cleanupAfterRun();
+ m_instance->setRunning(false);
+ Task::emitFailed(reason);
+}
+
+QString LaunchTask::substituteVariables(const QString &cmd) const
+{
+ QString out = cmd;
+ auto variables = m_instance->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;
+}
+
diff --git a/api/logic/launch/LaunchTask.h b/api/logic/launch/LaunchTask.h
new file mode 100644
index 00000000..447445ca
--- /dev/null
+++ b/api/logic/launch/LaunchTask.h
@@ -0,0 +1,122 @@
+/* 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.
+ */
+
+#pragma once
+#include <QProcess>
+#include "BaseInstance.h"
+#include "MessageLevel.h"
+#include "LoggedProcess.h"
+#include "LaunchStep.h"
+
+#include "multimc_logic_export.h"
+
+class MULTIMC_LOGIC_EXPORT LaunchTask: public Task
+{
+ Q_OBJECT
+protected:
+ explicit LaunchTask(InstancePtr instance);
+ void init();
+
+public:
+ enum State
+ {
+ NotStarted,
+ Running,
+ Waiting,
+ Failed,
+ Aborted,
+ Finished
+ };
+
+public: /* methods */
+ static std::shared_ptr<LaunchTask> create(InstancePtr inst);
+ virtual ~LaunchTask() {};
+
+ void appendStep(std::shared_ptr<LaunchStep> step);
+ void prependStep(std::shared_ptr<LaunchStep> step);
+ void setCensorFilter(QMap<QString, QString> filter);
+
+ InstancePtr instance()
+ {
+ return m_instance;
+ }
+
+ void setPid(qint64 pid)
+ {
+ m_pid = pid;
+ }
+
+ qint64 pid()
+ {
+ return m_pid;
+ }
+
+ /**
+ * @brief prepare the process for launch (for multi-stage launch)
+ */
+ virtual void executeTask() override;
+
+ /**
+ * @brief launch the armed instance
+ */
+ void proceed();
+
+ /**
+ * @brief abort launch
+ */
+ virtual bool abort() override;
+
+public:
+ QString substituteVariables(const QString &cmd) const;
+ QString censorPrivateInfo(QString in);
+
+protected: /* methods */
+ virtual void emitFailed(QString reason) override;
+ virtual void emitSucceeded() override;
+
+signals:
+ /**
+ * @brief emitted when the launch preparations are done
+ */
+ void readyForLaunch();
+
+ void requestProgress(Task *task);
+
+ void requestLogging();
+
+ /**
+ * @brief emitted when we want to log something
+ * @param text the text to log
+ * @param level the level to log at
+ */
+ void log(QString text, MessageLevel::Enum level = MessageLevel::MultiMC);
+
+public slots:
+ void onLogLines(const QStringList& lines, MessageLevel::Enum defaultLevel = MessageLevel::MultiMC);
+ void onLogLine(QString line, MessageLevel::Enum defaultLevel = MessageLevel::MultiMC);
+ void onReadyForLaunch();
+ void onStepFinished();
+ void onProgressReportingRequested();
+
+protected: /* data */
+ InstancePtr m_instance;
+ QList <std::shared_ptr<LaunchStep>> m_steps;
+ QMap<QString, QString> m_censorFilter;
+ int currentStep = -1;
+ State state = NotStarted;
+ qint64 m_pid = -1;
+};
diff --git a/api/logic/launch/LoggedProcess.cpp b/api/logic/launch/LoggedProcess.cpp
new file mode 100644
index 00000000..88ca40aa
--- /dev/null
+++ b/api/logic/launch/LoggedProcess.cpp
@@ -0,0 +1,163 @@
+#include "LoggedProcess.h"
+#include "MessageLevel.h"
+#include <QDebug>
+
+LoggedProcess::LoggedProcess(QObject *parent) : QProcess(parent)
+{
+ // QProcess has a strange interface... let's map a lot of those into a few.
+ connect(this, &QProcess::readyReadStandardOutput, this, &LoggedProcess::on_stdOut);
+ connect(this, &QProcess::readyReadStandardError, this, &LoggedProcess::on_stdErr);
+ connect(this, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(on_exit(int,QProcess::ExitStatus)));
+ connect(this, SIGNAL(error(QProcess::ProcessError)), this, SLOT(on_error(QProcess::ProcessError)));
+ connect(this, &QProcess::stateChanged, this, &LoggedProcess::on_stateChange);
+}
+
+QStringList reprocess(const QByteArray & data, QString & leftover)
+{
+ QString str = leftover + QString::fromLocal8Bit(data);
+
+ str.remove('\r');
+ QStringList lines = str.split("\n");
+ leftover = lines.takeLast();
+ return lines;
+}
+
+void LoggedProcess::on_stdErr()
+{
+ auto lines = reprocess(readAllStandardError(), m_err_leftover);
+ emit log(lines, MessageLevel::StdErr);
+}
+
+void LoggedProcess::on_stdOut()
+{
+ auto lines = reprocess(readAllStandardOutput(), m_out_leftover);
+ emit log(lines, MessageLevel::StdOut);
+}
+
+void LoggedProcess::on_exit(int exit_code, QProcess::ExitStatus status)
+{
+ // save the exit code
+ m_exit_code = exit_code;
+
+ // Flush console window
+ if (!m_err_leftover.isEmpty())
+ {
+ emit log({m_err_leftover}, MessageLevel::StdErr);
+ m_err_leftover.clear();
+ }
+ if (!m_out_leftover.isEmpty())
+ {
+ emit log({m_err_leftover}, MessageLevel::StdOut);
+ m_out_leftover.clear();
+ }
+
+ // based on state, send signals
+ if (!m_is_aborting)
+ {
+ if (status == QProcess::NormalExit)
+ {
+ //: Message displayed on instance exit
+ emit log({tr("Process exited with code %1.").arg(exit_code)}, MessageLevel::MultiMC);
+ changeState(LoggedProcess::Finished);
+ }
+ else
+ {
+ //: Message displayed on instance crashed
+ if(exit_code == -1)
+ emit log({tr("Process crashed.")}, MessageLevel::MultiMC);
+ else
+ emit log({tr("Process crashed with exitcode %1.").arg(exit_code)}, MessageLevel::MultiMC);
+ changeState(LoggedProcess::Crashed);
+ }
+ }
+ else
+ {
+ //: Message displayed after the instance exits due to kill request
+ emit log({tr("Process was killed by user.")}, MessageLevel::Error);
+ changeState(LoggedProcess::Aborted);
+ }
+}
+
+void LoggedProcess::on_error(QProcess::ProcessError error)
+{
+ switch(error)
+ {
+ case QProcess::FailedToStart:
+ {
+ emit log({tr("The process failed to start.")}, MessageLevel::Fatal);
+ changeState(LoggedProcess::FailedToStart);
+ break;
+ }
+ // we'll just ignore those... never needed them
+ case QProcess::Crashed:
+ case QProcess::ReadError:
+ case QProcess::Timedout:
+ case QProcess::UnknownError:
+ case QProcess::WriteError:
+ break;
+ }
+}
+
+void LoggedProcess::kill()
+{
+ m_is_aborting = true;
+ QProcess::kill();
+}
+
+int LoggedProcess::exitCode() const
+{
+ return m_exit_code;
+}
+
+void LoggedProcess::changeState(LoggedProcess::State state)
+{
+ if(state == m_state)
+ return;
+ m_state = state;
+ emit stateChanged(m_state);
+}
+
+LoggedProcess::State LoggedProcess::state() const
+{
+ return m_state;
+}
+
+void LoggedProcess::on_stateChange(QProcess::ProcessState state)
+{
+ switch(state)
+ {
+ case QProcess::NotRunning:
+ break; // let's not - there are too many that handle this already.
+ case QProcess::Starting:
+ {
+ if(m_state != LoggedProcess::NotRunning)
+ {
+ qWarning() << "Wrong state change for process from state" << m_state << "to" << (int) LoggedProcess::Starting;
+ }
+ changeState(LoggedProcess::Starting);
+ return;
+ }
+ case QProcess::Running:
+ {
+ if(m_state != LoggedProcess::Starting)
+ {
+ qWarning() << "Wrong state change for process from state" << m_state << "to" << (int) LoggedProcess::Running;
+ }
+ changeState(LoggedProcess::Running);
+ return;
+ }
+ }
+}
+
+#if defined Q_OS_WIN32
+#include <windows.h>
+#endif
+
+qint64 LoggedProcess::processId() const
+{
+#ifdef Q_OS_WIN
+ return pid() ? pid()->dwProcessId : 0;
+#else
+ return pid();
+#endif
+}
diff --git a/api/logic/launch/LoggedProcess.h b/api/logic/launch/LoggedProcess.h
new file mode 100644
index 00000000..baa53d79
--- /dev/null
+++ b/api/logic/launch/LoggedProcess.h
@@ -0,0 +1,76 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <QProcess>
+#include "MessageLevel.h"
+
+/*
+ * This is a basic process.
+ * It has line-based logging support and hides some of the nasty bits.
+ */
+class LoggedProcess : public QProcess
+{
+Q_OBJECT
+public:
+ enum State
+ {
+ NotRunning,
+ Starting,
+ FailedToStart,
+ Running,
+ Finished,
+ Crashed,
+ Aborted
+ };
+
+public:
+ explicit LoggedProcess(QObject* parent = 0);
+ virtual ~LoggedProcess() {};
+
+ State state() const;
+ int exitCode() const;
+ qint64 processId() const;
+
+signals:
+ void log(QStringList lines, MessageLevel::Enum level);
+ void stateChanged(LoggedProcess::State state);
+
+public slots:
+ /**
+ * @brief kill the process - equivalent to kill -9
+ */
+ void kill();
+
+
+private slots:
+ void on_stdErr();
+ void on_stdOut();
+ void on_exit(int exit_code, QProcess::ExitStatus status);
+ void on_error(QProcess::ProcessError error);
+ void on_stateChange(QProcess::ProcessState);
+
+private:
+ void changeState(LoggedProcess::State state);
+
+private:
+ QString m_err_leftover;
+ QString m_out_leftover;
+ bool m_killed = false;
+ State m_state = NotRunning;
+ int m_exit_code = 0;
+ bool m_is_aborting = false;
+};
diff --git a/api/logic/launch/MessageLevel.cpp b/api/logic/launch/MessageLevel.cpp
new file mode 100644
index 00000000..a5191290
--- /dev/null
+++ b/api/logic/launch/MessageLevel.cpp
@@ -0,0 +1,36 @@
+#include "MessageLevel.h"
+
+MessageLevel::Enum MessageLevel::getLevel(const QString& levelName)
+{
+ if (levelName == "MultiMC")
+ return MessageLevel::MultiMC;
+ else if (levelName == "Debug")
+ return MessageLevel::Debug;
+ else if (levelName == "Info")
+ return MessageLevel::Info;
+ else if (levelName == "Message")
+ return MessageLevel::Message;
+ else if (levelName == "Warning")
+ return MessageLevel::Warning;
+ else if (levelName == "Error")
+ return MessageLevel::Error;
+ else if (levelName == "Fatal")
+ return MessageLevel::Fatal;
+ // Skip PrePost, it's not exposed to !![]!
+ // Also skip StdErr and StdOut
+ else
+ return MessageLevel::Unknown;
+}
+
+MessageLevel::Enum MessageLevel::fromLine(QString &line)
+{
+ // Level prefix
+ int endmark = line.indexOf("]!");
+ if (line.startsWith("!![") && endmark != -1)
+ {
+ auto level = MessageLevel::getLevel(line.left(endmark).mid(3));
+ line = line.mid(endmark + 2);
+ return level;
+ }
+ return MessageLevel::Unknown;
+}
diff --git a/api/logic/launch/MessageLevel.h b/api/logic/launch/MessageLevel.h
new file mode 100644
index 00000000..0128148d
--- /dev/null
+++ b/api/logic/launch/MessageLevel.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <QString>
+
+/**
+ * @brief the MessageLevel Enum
+ * defines what level a log message is
+ */
+namespace MessageLevel
+{
+enum Enum
+{
+ Unknown, /**< No idea what this is or where it came from */
+ StdOut, /**< Undetermined stderr messages */
+ StdErr, /**< Undetermined stdout messages */
+ MultiMC, /**< MultiMC Messages */
+ Debug, /**< Debug Messages */
+ Info, /**< Info Messages */
+ Message, /**< Standard Messages */
+ Warning, /**< Warnings */
+ Error, /**< Errors */
+ Fatal, /**< Fatal Errors */
+};
+MessageLevel::Enum getLevel(const QString &levelName);
+
+/* Get message level from a line. Line is modified if it was successful. */
+MessageLevel::Enum fromLine(QString &line);
+}
diff --git a/api/logic/launch/steps/CheckJava.cpp b/api/logic/launch/steps/CheckJava.cpp
new file mode 100644
index 00000000..a4eaa307
--- /dev/null
+++ b/api/logic/launch/steps/CheckJava.cpp
@@ -0,0 +1,92 @@
+/* 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
+ *
+ * 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 "CheckJava.h"
+#include <launch/LaunchTask.h>
+#include <FileSystem.h>
+#include <QStandardPaths>
+#include <QFileInfo>
+
+void CheckJava::executeTask()
+{
+ auto instance = m_parent->instance();
+ auto settings = instance->settings();
+ m_javaPath = FS::ResolveExecutable(settings->get("JavaPath").toString());
+ bool perInstance = settings->get("OverrideJava").toBool() || settings->get("OverrideJavaLocation").toBool();
+
+ auto realJavaPath = QStandardPaths::findExecutable(m_javaPath);
+ if (realJavaPath.isEmpty())
+ {
+ if (perInstance)
+ {
+ emit logLine(
+ tr("The java binary \"%1\" couldn't be found. Please fix the java path "
+ "override in the instance's settings or disable it.").arg(m_javaPath),
+ MessageLevel::Warning);
+ }
+ else
+ {
+ emit logLine(tr("The java binary \"%1\" couldn't be found. Please set up java in "
+ "the settings.").arg(m_javaPath),
+ MessageLevel::Warning);
+ }
+ emitFailed(tr("Java path is not valid."));
+ return;
+ }
+ else
+ {
+ emit logLine("Java path is:\n" + m_javaPath + "\n\n", MessageLevel::MultiMC);
+ }
+
+ QFileInfo javaInfo(realJavaPath);
+ qlonglong javaUnixTime = javaInfo.lastModified().toMSecsSinceEpoch();
+ auto storedUnixTime = settings->get("JavaTimestamp").toLongLong();
+ m_javaUnixTime = javaUnixTime;
+ // if they are not the same, check!
+ if (javaUnixTime != storedUnixTime)
+ {
+ m_JavaChecker = std::make_shared<JavaChecker>();
+ QString errorLog;
+ QString version;
+ emit logLine(tr("Checking Java version..."), MessageLevel::MultiMC);
+ connect(m_JavaChecker.get(), &JavaChecker::checkFinished, this,
+ &CheckJava::checkJavaFinished);
+ m_JavaChecker->m_path = realJavaPath;
+ m_JavaChecker->performCheck();
+ return;
+ }
+ emitSucceeded();
+}
+
+void CheckJava::checkJavaFinished(JavaCheckResult result)
+{
+ if (!result.valid)
+ {
+ // Error message displayed if java can't start
+ emit logLine(tr("Could not start java:"), MessageLevel::Error);
+ emit logLines(result.errorLog.split('\n'), MessageLevel::Error);
+ emit logLine("\nCheck your MultiMC Java settings.", MessageLevel::MultiMC);
+ emitFailed(tr("Could not start java!"));
+ }
+ else
+ {
+ auto instance = m_parent->instance();
+ emit logLine(tr("Java version is %1!\n").arg(result.javaVersion.toString()),
+ MessageLevel::MultiMC);
+ instance->settings()->set("JavaVersion", result.javaVersion.toString());
+ instance->settings()->set("JavaTimestamp", m_javaUnixTime);
+ emitSucceeded();
+ }
+}
diff --git a/api/logic/launch/steps/CheckJava.h b/api/logic/launch/steps/CheckJava.h
new file mode 100644
index 00000000..b63dd4f4
--- /dev/null
+++ b/api/logic/launch/steps/CheckJava.h
@@ -0,0 +1,41 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <launch/LoggedProcess.h>
+#include <java/JavaChecker.h>
+
+class CheckJava: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit CheckJava(LaunchTask *parent) :LaunchStep(parent){};
+ virtual ~CheckJava() {};
+
+ virtual void executeTask();
+ virtual bool canAbort() const
+ {
+ return false;
+ }
+private slots:
+ void checkJavaFinished(JavaCheckResult result);
+
+private:
+ QString m_javaPath;
+ qlonglong m_javaUnixTime;
+ JavaCheckerPtr m_JavaChecker;
+};
diff --git a/api/logic/launch/steps/LaunchMinecraft.cpp b/api/logic/launch/steps/LaunchMinecraft.cpp
new file mode 100644
index 00000000..9b8cc0fb
--- /dev/null
+++ b/api/logic/launch/steps/LaunchMinecraft.cpp
@@ -0,0 +1,155 @@
+/* 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
+ *
+ * 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 "LaunchMinecraft.h"
+#include <launch/LaunchTask.h>
+#include <minecraft/MinecraftInstance.h>
+#include <FileSystem.h>
+#include <QStandardPaths>
+
+LaunchMinecraft::LaunchMinecraft(LaunchTask *parent) : LaunchStep(parent)
+{
+ connect(&m_process, &LoggedProcess::log, this, &LaunchMinecraft::logLines);
+ connect(&m_process, &LoggedProcess::stateChanged, this, &LaunchMinecraft::on_state);
+}
+
+void LaunchMinecraft::executeTask()
+{
+ auto instance = m_parent->instance();
+ std::shared_ptr<MinecraftInstance> minecraftInstance = std::dynamic_pointer_cast<MinecraftInstance>(instance);
+
+ m_launchScript = minecraftInstance->createLaunchScript(m_session);
+
+ QStringList args = minecraftInstance->javaArguments();
+
+ // HACK: this is a workaround for MCL-3732 - 'server-resource-packs' is created.
+ if(!FS::ensureFolderPathExists(FS::PathCombine(minecraftInstance->minecraftRoot(), "server-resource-packs")))
+ {
+ emit logLine(tr("Couldn't create the 'server-resource-packs' folder"), MessageLevel::Error);
+ }
+
+ QString allArgs = args.join(", ");
+ emit logLine("Java Arguments:\n[" + m_parent->censorPrivateInfo(allArgs) + "]\n\n", MessageLevel::MultiMC);
+
+ auto javaPath = FS::ResolveExecutable(instance->settings()->get("JavaPath").toString());
+
+ m_process.setProcessEnvironment(instance->createEnvironment());
+
+ QString wrapperCommand = instance->getWrapperCommand();
+ if(!wrapperCommand.isEmpty())
+ {
+ auto realWrapperCommand = QStandardPaths::findExecutable(wrapperCommand);
+ if (realWrapperCommand.isEmpty())
+ {
+ QString reason = tr("The wrapper command \"%1\" couldn't be found.").arg(wrapperCommand);
+ emit logLine(reason, MessageLevel::Fatal);
+ emitFailed(reason);
+ return;
+ }
+ emit logLine("Wrapper command is:\n" + wrapperCommand + "\n\n", MessageLevel::MultiMC);
+ args.prepend(javaPath);
+ m_process.start(wrapperCommand, args);
+ }
+ else
+ {
+ m_process.start(javaPath, args);
+ }
+}
+
+void LaunchMinecraft::on_state(LoggedProcess::State state)
+{
+ switch(state)
+ {
+ case LoggedProcess::FailedToStart:
+ {
+ //: Error message displayed if instace can't start
+ QString reason = tr("Could not launch minecraft!");
+ emit logLine(reason, MessageLevel::Fatal);
+ emitFailed(reason);
+ return;
+ }
+ case LoggedProcess::Aborted:
+ case LoggedProcess::Crashed:
+
+ {
+ m_parent->setPid(-1);
+ emitFailed("Game crashed.");
+ return;
+ }
+ case LoggedProcess::Finished:
+ {
+ m_parent->setPid(-1);
+ // if the exit code wasn't 0, report this as a crash
+ auto exitCode = m_process.exitCode();
+ if(exitCode != 0)
+ {
+ emitFailed("Game crashed.");
+ return;
+ }
+ //FIXME: make this work again
+ // m_postlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(exitCode));
+ // run post-exit
+ emitSucceeded();
+ break;
+ }
+ case LoggedProcess::Running:
+ emit logLine(tr("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC);
+ m_parent->setPid(m_process.processId());
+ m_parent->instance()->setLastLaunch();
+ // send the launch script to the launcher part
+ m_process.write(m_launchScript.toUtf8());
+ qDebug() << m_launchScript;
+
+ mayProceed = true;
+ emit readyForLaunch();
+ break;
+ default:
+ break;
+ }
+}
+
+void LaunchMinecraft::setWorkingDirectory(const QString &wd)
+{
+ m_process.setWorkingDirectory(wd);
+}
+
+void LaunchMinecraft::proceed()
+{
+ if(mayProceed)
+ {
+ QString launchString("launch\n");
+ m_process.write(launchString.toUtf8());
+ mayProceed = false;
+ }
+}
+
+bool LaunchMinecraft::abort()
+{
+ if(mayProceed)
+ {
+ mayProceed = false;
+ QString launchString("abort\n");
+ m_process.write(launchString.toUtf8());
+ }
+ else
+ {
+ auto state = m_process.state();
+ if (state == LoggedProcess::Running || state == LoggedProcess::Starting)
+ {
+ m_process.kill();
+ }
+ }
+ return true;
+}
diff --git a/api/logic/launch/steps/LaunchMinecraft.h b/api/logic/launch/steps/LaunchMinecraft.h
new file mode 100644
index 00000000..6b9f7919
--- /dev/null
+++ b/api/logic/launch/steps/LaunchMinecraft.h
@@ -0,0 +1,48 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <launch/LoggedProcess.h>
+#include <minecraft/auth/AuthSession.h>
+
+class LaunchMinecraft: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit LaunchMinecraft(LaunchTask *parent);
+ virtual void executeTask();
+ virtual bool abort();
+ virtual void proceed();
+ virtual bool canAbort() const
+ {
+ return true;
+ }
+ void setWorkingDirectory(const QString &wd);
+ void setAuthSession(AuthSessionPtr session)
+ {
+ m_session = session;
+ }
+private slots:
+ void on_state(LoggedProcess::State state);
+
+private:
+ LoggedProcess m_process;
+ QString m_command;
+ QString m_launchScript;
+ AuthSessionPtr m_session;
+ bool mayProceed = false;
+};
diff --git a/api/logic/launch/steps/ModMinecraftJar.cpp b/api/logic/launch/steps/ModMinecraftJar.cpp
new file mode 100644
index 00000000..fce2d70a
--- /dev/null
+++ b/api/logic/launch/steps/ModMinecraftJar.cpp
@@ -0,0 +1,44 @@
+/* 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
+ *
+ * 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 "ModMinecraftJar.h"
+#include <launch/LaunchTask.h>
+#include <QStandardPaths>
+
+void ModMinecraftJar::executeTask()
+{
+ m_jarModTask = m_parent->instance()->createJarModdingTask();
+ if(m_jarModTask)
+ {
+ connect(m_jarModTask.get(), SIGNAL(finished()), this, SLOT(jarModdingFinished()));
+ m_jarModTask->start();
+ return;
+ }
+ emitSucceeded();
+}
+
+void ModMinecraftJar::jarModdingFinished()
+{
+ if(m_jarModTask->successful())
+ {
+ emitSucceeded();
+ }
+ else
+ {
+ QString reason = tr("jar modding failed because: %1.\n\n").arg(m_jarModTask->failReason());
+ emit logLine(reason, MessageLevel::Fatal);
+ emitFailed(reason);
+ }
+}
diff --git a/api/logic/launch/steps/ModMinecraftJar.h b/api/logic/launch/steps/ModMinecraftJar.h
new file mode 100644
index 00000000..b35dfafa
--- /dev/null
+++ b/api/logic/launch/steps/ModMinecraftJar.h
@@ -0,0 +1,39 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <memory>
+
+// FIXME: temporary wrapper for existing task.
+class ModMinecraftJar: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit ModMinecraftJar(LaunchTask *parent) : LaunchStep(parent) {};
+ virtual ~ModMinecraftJar(){};
+
+ virtual void executeTask();
+ virtual bool canAbort() const
+ {
+ return false;
+ }
+private slots:
+ void jarModdingFinished();
+
+private:
+ std::shared_ptr<Task> m_jarModTask;
+};
diff --git a/api/logic/launch/steps/PostLaunchCommand.cpp b/api/logic/launch/steps/PostLaunchCommand.cpp
new file mode 100644
index 00000000..29a45f1b
--- /dev/null
+++ b/api/logic/launch/steps/PostLaunchCommand.cpp
@@ -0,0 +1,84 @@
+/* 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
+ *
+ * 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 "PostLaunchCommand.h"
+#include <launch/LaunchTask.h>
+
+PostLaunchCommand::PostLaunchCommand(LaunchTask *parent) : LaunchStep(parent)
+{
+ auto instance = m_parent->instance();
+ m_command = instance->getPostExitCommand();
+ m_process.setProcessEnvironment(instance->createEnvironment());
+ connect(&m_process, &LoggedProcess::log, this, &PostLaunchCommand::logLines);
+ connect(&m_process, &LoggedProcess::stateChanged, this, &PostLaunchCommand::on_state);
+}
+
+void PostLaunchCommand::executeTask()
+{
+ QString postlaunch_cmd = m_parent->substituteVariables(m_command);
+ emit logLine(tr("Running Post-Launch command: %1").arg(postlaunch_cmd), MessageLevel::MultiMC);
+ m_process.start(postlaunch_cmd);
+}
+
+void PostLaunchCommand::on_state(LoggedProcess::State state)
+{
+ auto getError = [&]()
+ {
+ return tr("Post-Launch command failed with code %1.\n\n").arg(m_process.exitCode());
+ };
+ switch(state)
+ {
+ case LoggedProcess::Aborted:
+ case LoggedProcess::Crashed:
+ case LoggedProcess::FailedToStart:
+ {
+ auto error = getError();
+ emit logLine(error, MessageLevel::Fatal);
+ emitFailed(error);
+ return;
+ }
+ case LoggedProcess::Finished:
+ {
+ if(m_process.exitCode() != 0)
+ {
+ auto error = getError();
+ emit logLine(error, MessageLevel::Fatal);
+ emitFailed(error);
+ }
+ else
+ {
+ emit logLine(tr("Post-Launch command ran successfully.\n\n"), MessageLevel::MultiMC);
+ emitSucceeded();
+ }
+ }
+ default:
+ break;
+ }
+}
+
+void PostLaunchCommand::setWorkingDirectory(const QString &wd)
+{
+ m_process.setWorkingDirectory(wd);
+}
+
+bool PostLaunchCommand::abort()
+{
+ auto state = m_process.state();
+ if (state == LoggedProcess::Running || state == LoggedProcess::Starting)
+ {
+ m_process.kill();
+ }
+ return true;
+}
diff --git a/api/logic/launch/steps/PostLaunchCommand.h b/api/logic/launch/steps/PostLaunchCommand.h
new file mode 100644
index 00000000..4d5b0a52
--- /dev/null
+++ b/api/logic/launch/steps/PostLaunchCommand.h
@@ -0,0 +1,39 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <launch/LoggedProcess.h>
+
+class PostLaunchCommand: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit PostLaunchCommand(LaunchTask *parent);
+ virtual void executeTask();
+ virtual bool abort();
+ virtual bool canAbort() const
+ {
+ return true;
+ }
+ void setWorkingDirectory(const QString &wd);
+private slots:
+ void on_state(LoggedProcess::State state);
+
+private:
+ LoggedProcess m_process;
+ QString m_command;
+};
diff --git a/api/logic/launch/steps/PreLaunchCommand.cpp b/api/logic/launch/steps/PreLaunchCommand.cpp
new file mode 100644
index 00000000..47197a82
--- /dev/null
+++ b/api/logic/launch/steps/PreLaunchCommand.cpp
@@ -0,0 +1,85 @@
+/* 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
+ *
+ * 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 "PreLaunchCommand.h"
+#include <launch/LaunchTask.h>
+
+PreLaunchCommand::PreLaunchCommand(LaunchTask *parent) : LaunchStep(parent)
+{
+ auto instance = m_parent->instance();
+ m_command = instance->getPreLaunchCommand();
+ m_process.setProcessEnvironment(instance->createEnvironment());
+ connect(&m_process, &LoggedProcess::log, this, &PreLaunchCommand::logLines);
+ connect(&m_process, &LoggedProcess::stateChanged, this, &PreLaunchCommand::on_state);
+}
+
+void PreLaunchCommand::executeTask()
+{
+ //FIXME: where to put this?
+ QString prelaunch_cmd = m_parent->substituteVariables(m_command);
+ emit logLine(tr("Running Pre-Launch command: %1").arg(prelaunch_cmd), MessageLevel::MultiMC);
+ m_process.start(prelaunch_cmd);
+}
+
+void PreLaunchCommand::on_state(LoggedProcess::State state)
+{
+ auto getError = [&]()
+ {
+ return tr("Pre-Launch command failed with code %1.\n\n").arg(m_process.exitCode());
+ };
+ switch(state)
+ {
+ case LoggedProcess::Aborted:
+ case LoggedProcess::Crashed:
+ case LoggedProcess::FailedToStart:
+ {
+ auto error = getError();
+ emit logLine(error, MessageLevel::Fatal);
+ emitFailed(error);
+ return;
+ }
+ case LoggedProcess::Finished:
+ {
+ if(m_process.exitCode() != 0)
+ {
+ auto error = getError();
+ emit logLine(error, MessageLevel::Fatal);
+ emitFailed(error);
+ }
+ else
+ {
+ emit logLine(tr("Pre-Launch command ran successfully.\n\n"), MessageLevel::MultiMC);
+ emitSucceeded();
+ }
+ }
+ default:
+ break;
+ }
+}
+
+void PreLaunchCommand::setWorkingDirectory(const QString &wd)
+{
+ m_process.setWorkingDirectory(wd);
+}
+
+bool PreLaunchCommand::abort()
+{
+ auto state = m_process.state();
+ if (state == LoggedProcess::Running || state == LoggedProcess::Starting)
+ {
+ m_process.kill();
+ }
+ return true;
+}
diff --git a/api/logic/launch/steps/PreLaunchCommand.h b/api/logic/launch/steps/PreLaunchCommand.h
new file mode 100644
index 00000000..077bdfca
--- /dev/null
+++ b/api/logic/launch/steps/PreLaunchCommand.h
@@ -0,0 +1,39 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <launch/LoggedProcess.h>
+
+class PreLaunchCommand: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit PreLaunchCommand(LaunchTask *parent);
+ virtual void executeTask();
+ virtual bool abort();
+ virtual bool canAbort() const
+ {
+ return true;
+ }
+ void setWorkingDirectory(const QString &wd);
+private slots:
+ void on_state(LoggedProcess::State state);
+
+private:
+ LoggedProcess m_process;
+ QString m_command;
+};
diff --git a/api/logic/launch/steps/TextPrint.cpp b/api/logic/launch/steps/TextPrint.cpp
new file mode 100644
index 00000000..f307b1fd
--- /dev/null
+++ b/api/logic/launch/steps/TextPrint.cpp
@@ -0,0 +1,29 @@
+#include "TextPrint.h"
+
+TextPrint::TextPrint(LaunchTask * parent, const QStringList &lines, MessageLevel::Enum level) : LaunchStep(parent)
+{
+ m_lines = lines;
+ m_level = level;
+}
+TextPrint::TextPrint(LaunchTask *parent, const QString &line, MessageLevel::Enum level) : LaunchStep(parent)
+{
+ m_lines.append(line);
+ m_level = level;
+}
+
+void TextPrint::executeTask()
+{
+ emit logLines(m_lines, m_level);
+ emitSucceeded();
+}
+
+bool TextPrint::canAbort() const
+{
+ return true;
+}
+
+bool TextPrint::abort()
+{
+ emitFailed("Aborted.");
+ return true;
+}
diff --git a/api/logic/launch/steps/TextPrint.h b/api/logic/launch/steps/TextPrint.h
new file mode 100644
index 00000000..fdd9014a
--- /dev/null
+++ b/api/logic/launch/steps/TextPrint.h
@@ -0,0 +1,43 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <launch/LoggedProcess.h>
+#include <java/JavaChecker.h>
+
+#include "multimc_logic_export.h"
+
+/*
+ * FIXME: maybe do not export
+ */
+
+class MULTIMC_LOGIC_EXPORT TextPrint: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit TextPrint(LaunchTask *parent, const QStringList &lines, MessageLevel::Enum level);
+ explicit TextPrint(LaunchTask *parent, const QString &line, MessageLevel::Enum level);
+ virtual ~TextPrint(){};
+
+ virtual void executeTask();
+ virtual bool canAbort() const;
+ virtual bool abort();
+
+private:
+ QStringList m_lines;
+ MessageLevel::Enum m_level;
+};
diff --git a/api/logic/launch/steps/Update.cpp b/api/logic/launch/steps/Update.cpp
new file mode 100644
index 00000000..4901f001
--- /dev/null
+++ b/api/logic/launch/steps/Update.cpp
@@ -0,0 +1,50 @@
+/* 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
+ *
+ * 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 "Update.h"
+#include <launch/LaunchTask.h>
+
+void Update::executeTask()
+{
+ m_updateTask = m_parent->instance()->createUpdateTask();
+ if(m_updateTask)
+ {
+ connect(m_updateTask.get(), SIGNAL(finished()), this, SLOT(updateFinished()));
+ connect(m_updateTask.get(), &Task::progress, this, &Task::setProgress);
+ connect(m_updateTask.get(), &Task::status, this, &Task::setStatus);
+ emit progressReportingRequest();
+ return;
+ }
+ emitSucceeded();
+}
+
+void Update::proceed()
+{
+ m_updateTask->start();
+}
+
+void Update::updateFinished()
+{
+ if(m_updateTask->successful())
+ {
+ emitSucceeded();
+ }
+ else
+ {
+ QString reason = tr("Instance update failed because: %1.\n\n").arg(m_updateTask->failReason());
+ emit logLine(reason, MessageLevel::Fatal);
+ emitFailed(reason);
+ }
+}
diff --git a/api/logic/launch/steps/Update.h b/api/logic/launch/steps/Update.h
new file mode 100644
index 00000000..14928253
--- /dev/null
+++ b/api/logic/launch/steps/Update.h
@@ -0,0 +1,41 @@
+/* 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
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <launch/LoggedProcess.h>
+#include <java/JavaChecker.h>
+
+// FIXME: stupid. should be defined by the instance type? or even completely abstracted away...
+class Update: public LaunchStep
+{
+ Q_OBJECT
+public:
+ explicit Update(LaunchTask *parent):LaunchStep(parent) {};
+ virtual ~Update() {};
+
+ virtual void executeTask();
+ virtual bool canAbort() const
+ {
+ return false;
+ }
+ virtual void proceed();
+private slots:
+ void updateFinished();
+
+private:
+ std::shared_ptr<Task> m_updateTask;
+};