AProcess.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
//
// Created by alex2 on 31.10.2020.
//
 
#pragma once
 
#include <AUI/IO/APath.h>
#include <AUI/Common/AException.h>
#include <AUI/Common/AVector.h>
#include <AUI/Common/AObject.h>
#include <AUI/Common/ASignal.h>
#include <AUI/IO/IInputStream.h>
#include <AUI/IO/IOutputStream.h>
#include <AUI/Thread/AFuture.h>
 
#if AUI_PLATFORM_WIN
#include <AUI/Platform/win32/AWin32EventWait.h>
#include <AUI/Platform/win32/WinIoAsync.h>
#include <windows.h>
#include "Pipe.h"
#else
#include "AUI/Platform/unix/UnixIoAsync.h"
#endif
 
class AChildProcess;

AUI_ENUM_FLAG(ASubProcessExecutionFlags) {
    MERGE_STDOUT_STDERR = 0b001,
    TIE_STDOUT = 0b010,
    TIE_STDERR = 0b100, DEFAULT = 0
};
 
class AProcessException : public AException {
public:
    AProcessException(const AString& message) : AException(message) {}
};

class API_AUI_CORE AProcess : public aui::noncopyable {
public:
    virtual ~AProcess() = default;

    virtual APath getModuleName() = 0;

    virtual APath getPathToExecutable() = 0;

    virtual uint32_t getPid() const noexcept = 0;

    virtual int waitForExitCode() = 0;

    virtual size_t processMemory() const = 0;

    struct ArgSingleString {
        AString arg;
    };

    struct ArgStringList {
        AStringVector list;

        bool win32WrapWhitespaceArgumentsWithQuots = true;
    };

    struct ProcessCreationInfo {
        APath executable;

        std::variant<ArgSingleString, ArgStringList> args;

        APath workDir;
    };

    static _<AChildProcess> create(ProcessCreationInfo args);

    [[deprecated("use AProcess::create instead")]]
    static _<AChildProcess> make(AString applicationFile, AString args = {}, APath workingDirectory = {}) {
        return create(
            { .executable = std::move(applicationFile),
              .args = ArgSingleString { std::move(args) },
              .workDir = std::move(workingDirectory) });
    }

    [[deprecated("use auto process = AProcess::make(); process->run(); process->waitForExitCode()")]]
    static int executeWaitForExit(
        AString applicationFile, AString args = {}, APath workingDirectory = {},
        ASubProcessExecutionFlags flags = ASubProcessExecutionFlags::DEFAULT);
 
#if AUI_PLATFORM_WIN

    static void executeAsAdministrator(
        const AString& applicationFile, const AString& args = {}, const APath& workingDirectory = {});
 
#endif

    static AVector<_<AProcess>> all();

    static _<AProcess> self();

    static _<AProcess> findAnotherSelfInstance(const AString& yourProjectName);

    static _<AProcess> fromPid(uint32_t pid);
 
    void kill() const noexcept;
};

class API_AUI_CORE AChildProcess : public AProcess, public AObject {
    friend class AProcess;
 
public:
    ~AChildProcess();
 
    [[nodiscard]]
    const auto& getApplicationFile() const {
        return mInfo.executable;
    }
 
    [[nodiscard]]
    const auto& getArgs() const {
        return mInfo.args;
    }
 
    [[nodiscard]]
    const auto& getWorkingDirectory() const {
        return mInfo.workDir;
    }
 
    APath getPathToExecutable() override {
        return getApplicationFile();
    }
 
    [[nodiscard]]
    AOptional<int> exitCodeNonBlocking() const noexcept {
        if (mExitCode.hasValue()) {
            return *mExitCode;
        }
        return std::nullopt;
    }
 
    [[nodiscard]]
    bool isFinished() const noexcept {
        return mExitCode.hasValue();
    }

    void run(ASubProcessExecutionFlags flags = ASubProcessExecutionFlags::DEFAULT);

    int waitForExitCode() override;
 
    uint32_t getPid() const noexcept override;
 
    size_t processMemory() const override;
 
    APath getModuleName() override;
 
    [[nodiscard]]
    const _<IOutputStream>& getStdInStream() const {
        return mStdInStream;
    }
 
signals:
    emits<> finished;
    emits<AByteBuffer> stdOut;
    emits<AByteBuffer> stdErr;
 
private:
    AChildProcess() = default;
    ProcessCreationInfo mInfo;
 
    _<IOutputStream> mStdInStream;
 
 
    AFuture<int> mExitCode;
#if AUI_PLATFORM_WIN
    PROCESS_INFORMATION mProcessInformation;
    AWin32EventWait mExitEvent;
    WinIoAsync mStdoutAsync;
#else
    pid_t mPid;
    _<AThread> mWatchdog;
    UnixIoAsync mStdoutAsync;
#endif
};