MonitoredProcess.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformProcess.h"
#include "HAL/Runnable.h"
#include "Misc/DateTime.h"
#include "Misc/SingleThreadRunnable.h"
#include "Misc/Timespan.h"
 
class FRunnableThread;
 
DECLARE_DELEGATE_OneParam(FOnMonitoredProcessCompleted, int32)
 
 
DECLARE_DELEGATE_OneParam(FOnMonitoredProcessOutput, FString)
 
 
 
class FMonitoredProcess
    : public FRunnable, FSingleThreadRunnable
{
public:
 
    CORE_API FMonitoredProcess( const FString& InURL, const FString& InParams, bool InHidden, bool InCreatePipes = true );
 
    CORE_API FMonitoredProcess( const FString& InURL, const FString& InParams, const FString& InWorkingDir, bool InHidden, bool InCreatePipes = true );
 
    CORE_API virtual ~FMonitoredProcess();
 
public:
 
    void Cancel( bool InKillTree = false )
    {
        KillTree = InKillTree;
        Canceling = true;
    }
 
    CORE_API FTimespan GetDuration() const;
 
    FProcHandle GetProcessHandle() const
    {
        return ProcessHandle;
    }
 
    FString GetCommandline() const
    {
        return FString::Printf(TEXT("%s %s"), *URL, *Params);
    }
 
    CORE_API bool Update();
 
    CORE_API virtual bool Launch();
 
    void SetSleepInterval( float InSleepInterval )
    {
        SleepInterval = InSleepInterval;
    }
 
public:
 
    FSimpleDelegate& OnCanceled()
    {
        return CanceledDelegate;
    }
 
    FOnMonitoredProcessCompleted& OnCompleted()
    {
        return CompletedDelegate;
    }
 
    FOnMonitoredProcessOutput& OnOutput()
    {
        return OutputDelegate;
    }
 
    CORE_API int GetReturnCode() const;
 
    CORE_API const FString& GetFullOutputWithoutDelegate() const;
 
public:
 
    // FRunnable interface
 
    virtual bool Init() override
    {
        return true;
    }
 
    CORE_API virtual uint32 Run() override;
 
    virtual void Stop() override
    {
        Cancel();
    }
 
    virtual void Exit() override { }
 
    virtual FSingleThreadRunnable* GetSingleThreadInterface() override
    {
        return this;
    }
 
protected:
 
    CORE_API void Tick() override;
 
    CORE_API void ProcessOutput( const FString& Output );
 
protected:
    CORE_API void TickInternal();
 
 
    // Whether the process is being canceled. */
    TAtomic<bool> Canceling = false;
 
    // Holds the time at which the process ended. */
    TAtomic<FDateTime> EndTime;
 
    // Whether the window of the process should be hidden. */
    bool Hidden = false;
 
    // Whether to kill the entire process tree when cancelling this process. */
    TAtomic<bool> KillTree = false;
 
    // Holds the command line parameters. */
    FString Params;
 
    // Holds the handle to the process. */
    FProcHandle ProcessHandle;
 
    // Holds the non-inheritable read end of stdout pipe. */
    void* ReadPipe = nullptr;
 
    // Holds the return code. */
    TAtomic<int> ReturnCode = 0;
 
    // Holds the time at which the process started. */
    TAtomic<FDateTime> StartTime { 0 };
 
    // Holds the monitoring thread object. */
    FRunnableThread* Thread = nullptr;
 
    // Is the thread running? 
    TAtomic<bool> bIsRunning;
 
    // Holds the URL of the executable to launch. */
    FString URL;
 
    // Holds the URL of the working dir for the process. */
    FString WorkingDir;
 
    // Holds the inheritable write end of stdout pipe. */
    void* WritePipe = nullptr;
 
    // Holds if we should create pipes
    bool bCreatePipes = false;
 
    // Sleep interval to use
    float SleepInterval = 0.01f;
 
    // Buffered output text which does not contain a newline
    FString OutputBuffer;
 
protected:
 
    // Holds a delegate that is executed when the process has been canceled. */
    FSimpleDelegate CanceledDelegate;
 
    // Holds a delegate that is executed when a monitored process completed. */
    FOnMonitoredProcessCompleted CompletedDelegate;
 
    // Holds a delegate that is executed when a monitored process produces output. */
    FOnMonitoredProcessOutput OutputDelegate;
};
 
 
class FSerializedUATProcess : public FMonitoredProcess
{
public:
    static CORE_API FString GetUATPath();
 
public:
    CORE_API FSerializedUATProcess(const FString& RunUATCommandline);
 
    CORE_API virtual bool Launch() override;
 
    FSimpleDelegate& OnLaunchFailed()
    {
        return LaunchFailedDelegate;
    }
 
 
private:
 
    CORE_API bool LaunchNext();
    CORE_API bool LaunchInternal();
    static CORE_API void CancelQueue();
 
    // When this one completes, run the next in line
    FSerializedUATProcess* NextProcessToRun = nullptr;
 
    // Holds a delegate that is executed when the process fails to launch (delayed, in a thread). Used in place of the return value
    // of Launch in the parent class, since it's async
    FSimpleDelegate LaunchFailedDelegate;
 
    static CORE_API FCriticalSection Serializer;
    static CORE_API bool bHasSucceededOnce;
    static CORE_API FSerializedUATProcess* HeadProcess;
};