Implement Project Manager 'build' button for Mac and Linux(#4248)

Signed-off-by: Steve Pham <spham@amazon.com>

Code/Tools/ProjectManager/Source/ProjectBuilderWorker.cpp

@@ -8,8 +8,15 @@
 
 #include <ProjectBuilderWorker.h>
 #include <ProjectManagerDefs.h>
+#include <PythonBindingsInterface.h>
+#include <ProjectUtils.h>
 
 #include <QDir>
+#include <QFile>
+#include <QProcess>
+#include <QProcessEnvironment>
+#include <QTextStream>
+#include <QThread>
 
 //#define MOCK_BUILD_PROJECT true
 
@@ -67,4 +74,176 @@ namespace O3DE::ProjectManager
     {
         AZ_TracePrintf("Project Manager", error.toStdString().c_str());
     }
+
+    AZ::Outcome<void, QString> ProjectBuilderWorker::BuildProjectForPlatform()
+    {
+        // Check if we are trying to cancel task
+        if (QThread::currentThread()->isInterruptionRequested())
+        {
+            QStringToAZTracePrint(BuildCancelled);
+            return AZ::Failure(BuildCancelled);
+        }
+
+        QFile logFile(GetLogFilePath());
+        if (!logFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
+        {
+            QString error = tr("Failed to open log file.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        EngineInfo engineInfo;
+
+        AZ::Outcome<EngineInfo> engineInfoResult = PythonBindingsInterface::Get()->GetEngineInfo();
+        if (engineInfoResult.IsSuccess())
+        {
+            engineInfo = engineInfoResult.GetValue();
+        }
+        else
+        {
+            QString error = tr("Failed to get engine info.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        QTextStream logStream(&logFile);
+        if (QThread::currentThread()->isInterruptionRequested())
+        {
+            logFile.close();
+            QStringToAZTracePrint(BuildCancelled);
+            return AZ::Failure(BuildCancelled);
+        }
+
+        // Show some kind of progress with very approximate estimates
+        UpdateProgress(++m_progressEstimate);
+
+        auto currentEnvironmentRequest = ProjectUtils::GetCommandLineProcessEnvironment();
+        if (!currentEnvironmentRequest.IsSuccess())
+        {
+            QStringToAZTracePrint(currentEnvironmentRequest.GetError());
+            return AZ::Failure(currentEnvironmentRequest.GetError());
+        }
+        QProcessEnvironment currentEnvironment = currentEnvironmentRequest.GetValue();
+
+        m_configProjectProcess = new QProcess(this);
+        m_configProjectProcess->setProcessChannelMode(QProcess::MergedChannels);
+        m_configProjectProcess->setWorkingDirectory(m_projectInfo.m_path);
+        m_configProjectProcess->setProcessEnvironment(currentEnvironment);
+
+        auto cmakeGenerateArgumentsResult = ConstructCmakeGenerateProjectArguments(engineInfo.m_thirdPartyPath);
+        if (!cmakeGenerateArgumentsResult.IsSuccess())
+        {
+            QStringToAZTracePrint(cmakeGenerateArgumentsResult.GetError());
+            return AZ::Failure(cmakeGenerateArgumentsResult.GetError());
+        }
+        auto cmakeGenerateArguments = cmakeGenerateArgumentsResult.GetValue();
+        m_configProjectProcess->start(cmakeGenerateArguments.front(), cmakeGenerateArguments.mid(1));
+        if (!m_configProjectProcess->waitForStarted())
+        {
+            QString error = tr("Configuring project failed to start.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+        bool containsGeneratingDone = false;
+        while (m_configProjectProcess->waitForReadyRead(MaxBuildTimeMSecs))
+        {
+            QString configOutput = m_configProjectProcess->readAllStandardOutput();
+
+            if (configOutput.contains("Generating done"))
+            {
+                containsGeneratingDone = true;
+            }
+
+            logStream << configOutput;
+            logStream.flush();
+
+            UpdateProgress(qMin(++m_progressEstimate, 19));
+
+            if (QThread::currentThread()->isInterruptionRequested())
+            {
+                logFile.close();
+                m_configProjectProcess->close();
+                QStringToAZTracePrint(BuildCancelled);
+                return AZ::Failure(BuildCancelled);
+            }
+        }
+
+        if (m_configProjectProcess->exitStatus() != QProcess::ExitStatus::NormalExit || m_configProjectProcess->exitCode() != 0 ||
+            !containsGeneratingDone)
+        {
+            QString error = tr("Configuring project failed. See log for details.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        UpdateProgress(++m_progressEstimate);
+
+        m_buildProjectProcess = new QProcess(this);
+        m_buildProjectProcess->setProcessChannelMode(QProcess::MergedChannels);
+        m_buildProjectProcess->setWorkingDirectory(m_projectInfo.m_path);
+        m_buildProjectProcess->setProcessEnvironment(currentEnvironment);
+
+        auto cmakeBuildArgumentsResult = ConstructCmakeBuildCommandArguments();
+        if (!cmakeBuildArgumentsResult.IsSuccess())
+        {
+            QStringToAZTracePrint(cmakeBuildArgumentsResult.GetError());
+            return AZ::Failure(cmakeBuildArgumentsResult.GetError());
+        }
+        auto cmakeBuildArguments = cmakeBuildArgumentsResult.GetValue();
+
+        m_buildProjectProcess->start(cmakeBuildArguments.front(), cmakeBuildArguments.mid(1));
+        if (!m_buildProjectProcess->waitForStarted())
+        {
+            QString error = tr("Building project failed to start.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        // There are a lot of steps when building so estimate around 800 more steps ((100 - 20) * 10) remaining
+        m_progressEstimate = 200;
+        while (m_buildProjectProcess->waitForReadyRead(MaxBuildTimeMSecs))
+        {
+            logStream << m_buildProjectProcess->readAllStandardOutput();
+            logStream.flush();
+
+            // Show 1% progress for every 10 steps completed
+            UpdateProgress(qMin(++m_progressEstimate / 10, 99));
+
+            if (QThread::currentThread()->isInterruptionRequested())
+            {
+                // QProcess is unable to kill its child processes so we need to ask the operating system to do that for us
+                auto killProcessArgumentsResult = ConstructKillProcessCommandArguments(QString::number(m_buildProjectProcess->processId()));
+                if (!killProcessArgumentsResult.IsSuccess())
+                {
+                    return AZ::Failure(killProcessArgumentsResult.GetError());
+                }
+                auto killProcessArguments = killProcessArgumentsResult.GetValue();
+
+
+                QProcess killBuildProcess;
+
+
+                killBuildProcess.setProcessChannelMode(QProcess::MergedChannels);
+                killBuildProcess.start(killProcessArguments.front(), killProcessArguments.mid(1));
+                killBuildProcess.waitForFinished();
+
+                logStream << "Killing Project Build.";
+                logStream << killBuildProcess.readAllStandardOutput();
+                m_buildProjectProcess->kill();
+                logFile.close();
+                QStringToAZTracePrint(BuildCancelled);
+                return AZ::Failure(BuildCancelled);
+            }
+        }
+
+        if (m_buildProjectProcess->exitStatus() != QProcess::ExitStatus::NormalExit || m_buildProjectProcess->exitCode() != 0)
+        {
+            QString error = tr("Building project failed. See log for details.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        return AZ::Success();
+    }
+
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectBuilderWorker.h

@@ -12,6 +12,7 @@
 #include <AzCore/Outcome/Outcome.h>
 
 #include <QObject>
+#include <QProcessEnvironment>
 #endif
 
 QT_FORWARD_DECLARE_CLASS(QProcess)
@@ -44,6 +45,12 @@ namespace O3DE::ProjectManager
         AZ::Outcome<void, QString> BuildProjectForPlatform();
         void QStringToAZTracePrint(const QString& error);
 
+        // Command line argument builders
+        AZ::Outcome<QStringList, QString> ConstructCmakeGenerateProjectArguments(const QString& thirdPartyPath) const;
+        AZ::Outcome<QStringList, QString> ConstructCmakeBuildCommandArguments() const;
+        AZ::Outcome<QStringList, QString> ConstructKillProcessCommandArguments(const QString& pidToKill) const;
+
+
         QProcess* m_configProjectProcess = nullptr;
         QProcess* m_buildProjectProcess = nullptr;
         ProjectInfo m_projectInfo;

Code/Tools/ProjectManager/Source/ProjectManagerDefs.h

@@ -14,6 +14,7 @@ namespace O3DE::ProjectManager
     inline constexpr static int ProjectPreviewImageWidth = 210;
     inline constexpr static int ProjectPreviewImageHeight = 280;
     inline constexpr static int ProjectTemplateImageWidth = 92;
+    inline constexpr static int ProjectCommandLineTimeoutSeconds = 30;
 
     static const QString ProjectBuildDirectoryName = "build";
     extern const QString ProjectBuildPathPostfix;
@@ -21,4 +22,8 @@ namespace O3DE::ProjectManager
     static const QString ProjectBuildErrorLogName = "CMakeProjectBuildError.log";
     static const QString ProjectCacheDirectoryName = "Cache";
     static const QString ProjectPreviewImagePath = "preview.png";
+    
+    static const QString ProjectCMakeCommand = "cmake";
+    static const QString ProjectCMakeBuildTargetEditor = "Editor";
+
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectUtils.cpp

@@ -22,6 +22,8 @@
 #include <QSpacerItem>
 #include <QGridLayout>
 
+#include <AzCore/std/chrono/chrono.h>
+
 namespace O3DE::ProjectManager
 {
     namespace ProjectUtils
@@ -507,5 +509,33 @@ namespace O3DE::ProjectManager
 
             return ProjectManagerScreen::Invalid;
         }
+
+        AZ::Outcome<QString, QString> ExecuteCommandResult(
+            const QString& cmd,
+            const QStringList& arguments,
+            const QProcessEnvironment& processEnv,
+            int commandTimeoutSeconds /*= ProjectCommandLineTimeoutSeconds*/)
+        {
+            QProcess execProcess;
+            execProcess.setProcessEnvironment(processEnv);
+            execProcess.setProcessChannelMode(QProcess::MergedChannels);
+            execProcess.start(cmd, arguments);
+            if (!execProcess.waitForStarted())
+            {
+                return AZ::Failure(QObject::tr("Unable to start process for command '%1'").arg(cmd));
+            }
+
+            if (!execProcess.waitForFinished(commandTimeoutSeconds * 1000 /* Milliseconds per second */))
+            {
+                return AZ::Failure(QObject::tr("Process for command '%1' timed out at %2 seconds").arg(cmd).arg(commandTimeoutSeconds));
+            }
+            int resultCode = execProcess.exitCode();
+            if (resultCode != 0)
+            {
+                return AZ::Failure(QObject::tr("Process for command '%1' failed (result code %2").arg(cmd).arg(resultCode));
+            }
+            QString resultOutput = execProcess.readAllStandardOutput();
+            return AZ::Success(resultOutput);
+        }
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectUtils.h

@@ -9,8 +9,11 @@
 
 #include <ScreenDefs.h>
 #include <ProjectInfo.h>
+#include <ProjectManagerDefs.h>
 
 #include <QWidget>
+#include <QProcessEnvironment>
+
 #include <AzCore/Outcome/Outcome.h>
 
 namespace O3DE::ProjectManager
@@ -28,8 +31,17 @@ namespace O3DE::ProjectManager
         bool ReplaceProjectFile(const QString& origFile, const QString& newFile, QWidget* parent = nullptr, bool interactive = true);
 
         bool FindSupportedCompiler(QWidget* parent = nullptr);
-        AZ::Outcome<void, QString> FindSupportedCompilerForPlatform();
+        AZ::Outcome<QString, QString> FindSupportedCompilerForPlatform();
 
         ProjectManagerScreen GetProjectManagerScreen(const QString& screen);
+
+        AZ::Outcome<QString, QString> ExecuteCommandResult(
+            const QString& cmd,
+            const QStringList& arguments,
+            const QProcessEnvironment& processEnv,
+            int commandTimeoutSeconds = ProjectCommandLineTimeoutSeconds);
+
+        AZ::Outcome<QProcessEnvironment, QString> GetCommandLineProcessEnvironment();
+
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/PythonBindings.cpp

@@ -339,7 +339,7 @@ namespace O3DE::ProjectManager
             {
                 for (auto engine : allEngines)
                 {
-                    AZ::IO::FixedMaxPath enginePath(Py_To_String(engine["path"]));
+                    AZ::IO::FixedMaxPath enginePath(Py_To_String(engine));
                     if (enginePath.Compare(m_enginePath) == 0)
                     {
                         return;