NOISSUE Flatten gui and logic libraries into MultiMC

10 files changed, 590 insertions, 0 deletions

diff --git a/launcher/launch/steps/LookupServerAddress.cpp b/launcher/launch/steps/LookupServerAddress.cpp
new file mode 100644
index 00000000..de56c28a
--- /dev/null
+++ b/launcher/launch/steps/LookupServerAddress.cpp
@@ -0,0 +1,95 @@
+/* Copyright 2013-2021 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 "LookupServerAddress.h"
+
+#include <launch/LaunchTask.h>
+
+LookupServerAddress::LookupServerAddress(LaunchTask *parent) :
+    LaunchStep(parent), m_dnsLookup(new QDnsLookup(this))
+{
+    connect(m_dnsLookup, &QDnsLookup::finished, this, &LookupServerAddress::on_dnsLookupFinished);
+
+    m_dnsLookup->setType(QDnsLookup::SRV);
+}
+
+void LookupServerAddress::setLookupAddress(const QString &lookupAddress)
+{
+    m_lookupAddress = lookupAddress;
+    m_dnsLookup->setName(QString("_minecraft._tcp.%1").arg(lookupAddress));
+}
+
+void LookupServerAddress::setOutputAddressPtr(MinecraftServerTargetPtr output)
+{
+    m_output = std::move(output);
+}
+
+bool LookupServerAddress::abort()
+{
+    m_dnsLookup->abort();
+    emitFailed("Aborted");
+    return true;
+}
+
+void LookupServerAddress::executeTask()
+{
+    m_dnsLookup->lookup();
+}
+
+void LookupServerAddress::on_dnsLookupFinished()
+{
+    if (isFinished())
+    {
+        // Aborted
+        return;
+    }
+
+    if (m_dnsLookup->error() != QDnsLookup::NoError)
+    {
+        emit logLine(QString("Failed to resolve server address (this is NOT an error!) %1: %2\n")
+            .arg(m_dnsLookup->name(), m_dnsLookup->errorString()), MessageLevel::MultiMC);
+        resolve(m_lookupAddress, 25565); // Technically the task failed, however, we don't abort the launch
+                                                      // and leave it up to minecraft to fail (or maybe not) when connecting
+        return;
+    }
+
+    const auto records = m_dnsLookup->serviceRecords();
+    if (records.empty())
+    {
+        emit logLine(
+                QString("Failed to resolve server address %1: the DNS lookup succeeded, but no records were returned.\n")
+                .arg(m_dnsLookup->name()), MessageLevel::Warning);
+        resolve(m_lookupAddress, 25565); // Technically the task failed, however, we don't abort the launch
+                                                      // and leave it up to minecraft to fail (or maybe not) when connecting
+        return;
+    }
+
+    const auto &firstRecord = records.at(0);
+    quint16 port = firstRecord.port();
+
+    emit logLine(QString("Resolved server address %1 to %2 with port %3\n").arg(
+            m_dnsLookup->name(), firstRecord.target(), QString::number(port)),MessageLevel::MultiMC);
+    resolve(firstRecord.target(), port);
+}
+
+void LookupServerAddress::resolve(const QString &address, quint16 port)
+{
+    m_output->address = address;
+    m_output->port = port;
+
+    emitSucceeded();
+    m_dnsLookup->deleteLater();
+}
diff --git a/launcher/launch/steps/LookupServerAddress.h b/launcher/launch/steps/LookupServerAddress.h
new file mode 100644
index 00000000..5a5c3de1
--- /dev/null
+++ b/launcher/launch/steps/LookupServerAddress.h
@@ -0,0 +1,49 @@
+/* Copyright 2013-2021 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 <QObjectPtr.h>
+#include <QDnsLookup>
+
+#include "minecraft/launch/MinecraftServerTarget.h"
+
+class LookupServerAddress: public LaunchStep {
+Q_OBJECT
+public:
+    explicit LookupServerAddress(LaunchTask *parent);
+    virtual ~LookupServerAddress() {};
+
+    virtual void executeTask();
+    virtual bool abort();
+    virtual bool canAbort() const
+    {
+        return true;
+    }
+
+    void setLookupAddress(const QString &lookupAddress);
+    void setOutputAddressPtr(MinecraftServerTargetPtr output);
+
+private slots:
+    void on_dnsLookupFinished();
+
+private:
+    void resolve(const QString &address, quint16 port);
+
+    QDnsLookup *m_dnsLookup;
+    QString m_lookupAddress;
+    MinecraftServerTargetPtr m_output;
+};
diff --git a/launcher/launch/steps/PostLaunchCommand.cpp b/launcher/launch/steps/PostLaunchCommand.cpp
new file mode 100644
index 00000000..d48d03d1
--- /dev/null
+++ b/launcher/launch/steps/PostLaunchCommand.cpp
@@ -0,0 +1,84 @@
+/* Copyright 2013-2021 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/launcher/launch/steps/PostLaunchCommand.h b/launcher/launch/steps/PostLaunchCommand.h
new file mode 100644
index 00000000..ab4c494f
--- /dev/null
+++ b/launcher/launch/steps/PostLaunchCommand.h
@@ -0,0 +1,41 @@
+/* Copyright 2013-2021 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 <LoggedProcess.h>
+
+class PostLaunchCommand: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit PostLaunchCommand(LaunchTask *parent);
+    virtual ~PostLaunchCommand() {};
+
+    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/launcher/launch/steps/PreLaunchCommand.cpp b/launcher/launch/steps/PreLaunchCommand.cpp
new file mode 100644
index 00000000..20e089e2
--- /dev/null
+++ b/launcher/launch/steps/PreLaunchCommand.cpp
@@ -0,0 +1,85 @@
+/* Copyright 2013-2021 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/launcher/launch/steps/PreLaunchCommand.h b/launcher/launch/steps/PreLaunchCommand.h
new file mode 100644
index 00000000..dc069f71
--- /dev/null
+++ b/launcher/launch/steps/PreLaunchCommand.h
@@ -0,0 +1,41 @@
+/* Copyright 2013-2021 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 "LoggedProcess.h"
+
+class PreLaunchCommand: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit PreLaunchCommand(LaunchTask *parent);
+    virtual ~PreLaunchCommand() {};
+
+    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/launcher/launch/steps/TextPrint.cpp b/launcher/launch/steps/TextPrint.cpp
new file mode 100644
index 00000000..0c1f320c
--- /dev/null
+++ b/launcher/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/launcher/launch/steps/TextPrint.h b/launcher/launch/steps/TextPrint.h
new file mode 100644
index 00000000..36fa7f9a
--- /dev/null
+++ b/launcher/launch/steps/TextPrint.h
@@ -0,0 +1,41 @@
+/* Copyright 2013-2021 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 <LoggedProcess.h>
+#include <java/JavaChecker.h>
+
+/*
+ * FIXME: maybe do not export
+ */
+
+class 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/launcher/launch/steps/Update.cpp b/launcher/launch/steps/Update.cpp
new file mode 100644
index 00000000..28bd153d
--- /dev/null
+++ b/launcher/launch/steps/Update.cpp
@@ -0,0 +1,80 @@
+/* Copyright 2013-2021 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()
+{
+    if(m_aborted)
+    {
+        emitFailed(tr("Task aborted."));
+        return;
+    }
+    m_updateTask.reset(m_parent->instance()->createUpdateTask(m_mode));
+    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->wasSuccessful())
+    {
+        m_updateTask.reset();
+        emitSucceeded();
+    }
+    else
+    {
+        QString reason = tr("Instance update failed because: %1\n\n").arg(m_updateTask->failReason());
+        m_updateTask.reset();
+        emit logLine(reason, MessageLevel::Fatal);
+        emitFailed(reason);
+    }
+}
+
+bool Update::canAbort() const
+{
+    if(m_updateTask)
+    {
+        return m_updateTask->canAbort();
+    }
+    return true;
+}
+
+
+bool Update::abort()
+{
+    m_aborted = true;
+    if(m_updateTask)
+    {
+        if(m_updateTask->canAbort())
+        {
+            return m_updateTask->abort();
+        }
+    }
+    return true;
+}
diff --git a/launcher/launch/steps/Update.h b/launcher/launch/steps/Update.h
new file mode 100644
index 00000000..0c9d91e0
--- /dev/null
+++ b/launcher/launch/steps/Update.h
@@ -0,0 +1,45 @@
+/* Copyright 2013-2021 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 <QObjectPtr.h>
+#include <LoggedProcess.h>
+#include <java/JavaChecker.h>
+#include <net/Mode.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, Net::Mode mode):LaunchStep(parent), m_mode(mode) {};
+    virtual ~Update() {};
+
+    void executeTask() override;
+    bool canAbort() const override;
+    void proceed() override;
+public slots:
+    bool abort() override;
+
+private slots:
+    void updateFinished();
+
+private:
+    shared_qobject_ptr<Task> m_updateTask;
+    bool m_aborted = false;
+    Net::Mode m_mode = Net::Mode::Offline;
+};