NOISSUE reorganize and document libraries

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();
+	}
+}

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;
+};

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;
+}

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;
+};

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);
+	}
+}

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;
+};

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;
+}

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;
+};

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;
+}

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;
+};

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;
+}

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;
+};

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);
+	}
+}

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;
+};