Process.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../File/File.h"
#include "../Foundation/AlignedStorage.h"
#include "../Foundation/Internal/IGrowableBuffer.h"
#include "../Foundation/StringPath.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT ProcessChain;
 
using ProcessDescriptor = FileDescriptor;
 
struct ProcessExitStatus
{
    int32_t status = -1;
};
 
 
 
struct ProcessID
{
    int32_t pid = 0;
};
 
 
struct SC_COMPILER_EXPORT Process
{
    struct SC_COMPILER_EXPORT Options
    {
        bool windowsHide; 
        Options();
    };
 
    struct StdStream
    {
        template <typename T>
        StdStream(T& destination)
        {
            GrowableBuffer<T>& gbuf = growableBufferStorage.reinterpret_as<GrowableBuffer<T>>();
            placementNew(gbuf, destination);
            growableBuffer = &gbuf;
            operation      = Operation::GrowableBuffer;
        }
        ~StdStream()
        {
            if (growableBuffer)
            {
                growableBuffer->~IGrowableBuffer();
            }
        }
 
        StdStream(FileDescriptor&& file)
        {
            operation = Operation::FileDescriptor;
            (void)file.get(fileDescriptor, Result::Error("Invalid redirection file descriptor"));
            file.detach();
        }
 
        StdStream(PipeDescriptor& pipe)
        {
            operation      = Operation::ExternalPipe;
            pipeDescriptor = &pipe;
        }
 
        StdStream(const StdStream&)            = delete;
        StdStream(StdStream&&)                 = delete;
        StdStream& operator=(const StdStream&) = delete;
        StdStream& operator=(StdStream&&)      = delete;
 
      protected:
        struct AlreadySetup
        {
        };
        StdStream() = default;
        StdStream(AlreadySetup) { operation = Operation::AlreadySetup; }
        friend struct Process;
        friend struct ProcessChain;
 
        enum class Operation
        {
            AlreadySetup,
            Inherit,
            Ignore,
            ExternalPipe,
            FileDescriptor,
            GrowableBuffer,
            WritableSpan,
            ReadableSpan
        };
        Operation operation = Operation::Inherit;
 
        Span<const char> readableSpan;
        Span<char>       writableSpan;
 
        IGrowableBuffer*                  growableBuffer = nullptr;
        AlignedStorage<6 * sizeof(void*)> growableBufferStorage;
 
        FileDescriptor::Handle fileDescriptor;
 
        PipeDescriptor* pipeDescriptor;
    };
 
    struct StdOut : public StdStream
    {
        // clang-format off
        struct Ignore{};
        struct Inherit{};
        
        StdOut(Ignore) { operation = Operation::Ignore; }
        
        StdOut(Inherit) { operation = Operation::Inherit; }
        
        StdOut(Span<char> span) { operation = Operation::WritableSpan; writableSpan = span; }
        
        using StdStream::StdStream;
        friend struct ProcessChain;
        // clang-format on
    };
 
    using StdErr = StdOut;
 
    struct StdIn : public StdStream
    {
        // clang-format off
        struct Inherit{};
        
        StdIn(Inherit) { operation = Operation::Inherit; }
        
        template <int N> StdIn(const char (&item)[N]) : StdIn(StringSpan({item, N - 1}, true, StringEncoding::Ascii)) {}
        
        StdIn(StringSpan string) : StdIn(string.toCharSpan()) {}
        
        StdIn(Span<const char> span) { operation = Operation::ReadableSpan; readableSpan = span;}
        
        using StdStream::StdStream;
        friend struct ProcessChain;
        // clang-format on
    };
 
    ProcessDescriptor handle;    
    ProcessID         processID; 
    Options           options;   
 
    Result waitForExitSync();
 
    Result launch(Span<const StringSpan> cmd,                        //
                  const StdOut&          stdOut = StdOut::Inherit{}, //
                  const StdIn&           stdIn  = StdIn::Inherit{},  //
                  const StdErr&          stdErr = StdErr::Inherit{})
    {
        SC_TRY(formatArguments(cmd));
        return launch(stdOut, stdIn, stdErr);
    }
 
    Result exec(Span<const StringSpan> cmd,                        //
                const StdOut&          stdOut = StdOut::Inherit{}, //
                const StdIn&           stdIn  = StdIn::Inherit{},  //
                const StdErr&          stdErr = StdErr::Inherit{})
    {
        SC_TRY(launch(cmd, stdOut, stdIn, stdErr));
        return waitForExitSync();
    }
 
    int32_t getExitStatus() const { return exitStatus.status; }
 
    Result setWorkingDirectory(StringSpan processWorkingDirectory);
 
    void inheritParentEnvironmentVariables(bool inherit) { inheritEnv = inherit; }
 
    Result setEnvironment(StringSpan environmentVariable, StringSpan value);
 
    [[nodiscard]] static size_t getNumberOfProcessors();
 
    [[nodiscard]] static bool isWindowsConsoleSubsystem();
 
    [[nodiscard]] static bool isWindowsEmulatedProcess();
 
    Process(Span<native_char_t> commandMemory = {}, Span<native_char_t> environmentMemory = {})
        : command({commandMemory}), environment({environmentMemory})
    {
        if (commandMemory.empty())
            command = {commandStorage};
        if (environmentMemory.empty())
            environment = {environmentStorage};
    }
 
  private:
    ProcessExitStatus exitStatus; 
 
    FileDescriptor stdInFd;  
    FileDescriptor stdOutFd; 
    FileDescriptor stdErrFd; 
 
    Result launch(const StdOut& stdOutput, const StdIn& stdInput, const StdErr& stdError);
 
    Result formatArguments(Span<const StringSpan> cmd);
 
    StringPath currentDirectory;
 
    // On Windows command holds the concatenation of executable and arguments.
    // On Posix command holds the concatenation of executable and arguments SEPARATED BY null-terminators (\0).
    // This is done so that in this single buffer with no allocation (under 255) or a single allocation (above 255)
    // we can track all arguments to be passed to execve.
    native_char_t              commandStorage[StringPath::MaxPath + 1024];
    StringSpan::NativeWritable command;
#if !SC_PLATFORM_WINDOWS // On Posix we need to track the "sub-strings" hidden in command
    static constexpr size_t MAX_NUM_ARGUMENTS = 64;
    size_t commandArgumentsByteOffset[MAX_NUM_ARGUMENTS]; // Tracking length of each argument in the command string
    size_t commandArgumentsNumber = 0;                    // Counts number of arguments (including executable name)
#endif
 
    native_char_t              environmentStorage[4096 * 4]; // 16K (w)chars of storage for environment variables
    StringSpan::NativeWritable environment;
 
    static constexpr size_t MAX_NUM_ENVIRONMENT = 256;
 
    size_t environmentByteOffset[MAX_NUM_ENVIRONMENT]; // Tracking length of each environment variable
    size_t environmentNumber = 0;                      // Counts number of environment variable
 
    bool inheritEnv = true;
 
    friend struct ProcessChain;
    ProcessChain* parent = nullptr;
 
    Process* next = nullptr;
    Process* prev = nullptr;
    struct Internal;
    friend struct ProcessFork;
    Result launchImplementation();
};
 
struct SC_COMPILER_EXPORT ProcessChain
{
    Process::Options options;
    Result pipe(Process& process, const Span<const StringSpan> cmd);
 
    Result launch(const Process::StdOut& stdOut = Process::StdOut::Inherit{}, //
                  const Process::StdIn&  stdIn  = Process::StdIn::Inherit{},  //
                  const Process::StdErr& stdErr = Process::StdErr::Inherit{});
 
    Result waitForExitSync();
 
    Result exec(const Process::StdOut& stdOut = Process::StdOut::Inherit{}, //
                const Process::StdIn&  stdIn  = Process::StdIn::Inherit{},  //
                const Process::StdErr& stdErr = Process::StdErr::Inherit{})
    {
        SC_TRY(launch(stdOut, stdIn, stdErr));
        return waitForExitSync();
    }
 
  private:
    // Trimmed duplicate of IntrusiveDoubleLinkedList<T>
    struct ProcessLinkedList
    {
        Process* back  = nullptr; // has no next
        Process* front = nullptr; // has no prev
 
        [[nodiscard]] bool isEmpty() const { return front == nullptr; }
 
        void clear();
        void queueBack(Process& process);
    };
    ProcessLinkedList processes;
};
 
struct ProcessEnvironment
{
    ProcessEnvironment();
    ~ProcessEnvironment();
 
    ProcessEnvironment(const ProcessEnvironment&)            = delete;
    ProcessEnvironment(ProcessEnvironment&&)                 = delete;
    ProcessEnvironment& operator=(const ProcessEnvironment&) = delete;
    ProcessEnvironment& operator=(ProcessEnvironment&&)      = delete;
 
    [[nodiscard]] size_t size() const { return numberOfEnvironment; }
 
    [[nodiscard]] bool get(size_t index, StringSpan& name, StringSpan& value) const;
 
    [[nodiscard]] bool contains(StringSpan variableName, size_t* index = nullptr);
 
  private:
    size_t numberOfEnvironment = 0;
#if SC_PLATFORM_WINDOWS
    static constexpr size_t MAX_ENVIRONMENTS = 256;
 
    StringSpan envStrings[MAX_ENVIRONMENTS];
    wchar_t*   environment = nullptr;
#else
    char** environment = nullptr;
#endif
};
 
struct SC_COMPILER_EXPORT ProcessFork
{
    ProcessFork();
    ~ProcessFork();
    ProcessFork(const ProcessFork&)            = delete;
    ProcessFork* operator=(const ProcessFork&) = delete;
 
    enum Side
    {
        ForkParent, 
        ForkChild,  
    };
 
    [[nodiscard]] Side getSide() const { return side; }
 
    enum State
    {
        Suspended, 
        Immediate, 
    };
 
    Result fork(State state);
 
    Result resumeChildFork();
 
    Result waitForChild();
 
    int32_t getExitStatus() const { return exitStatus.status; }
 
    FileDescriptor& getWritePipe();
 
    FileDescriptor& getReadPipe();
 
  private:
    Side side = ForkParent;
#if SC_PLATFORM_WINDOWS
    ProcessDescriptor::Handle processHandle = ProcessDescriptor::Invalid;
    ProcessDescriptor::Handle threadHandle  = ProcessDescriptor::Invalid;
#else
    ProcessID processID;
#endif
    ProcessExitStatus exitStatus; 
 
    PipeDescriptor parentToFork; 
    PipeDescriptor forkToParent; 
};
 
} // namespace SC