process.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_PROCESS_HPP__
#define NEFORCE_CORE_SYSTEM_PROCESS_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/thread.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/system/pipe.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct process_exception final : system_exception {
    explicit process_exception(const char* info = "Process Operation Failed.",
                               const error_code code = last_error()) noexcept :
    system_exception(info, code) {}
 
    explicit process_exception(const exception& e) :
    system_exception(e) {}
 
    ~process_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "process_exception"; }
};
 // Exceptions


class NEFORCE_API process {
public:
    using native_id_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            unsigned long;
#else
            int;
#endif

    enum class std_stream {
        stdin,  
        stdout, 
        stderr  
    };

    struct memory_info {
        size_t working_set_size{0};      
        size_t peak_working_set_size{0}; 
        size_t pagefile_usage{0};        
        size_t peak_pagefile_usage{0};   
    };

    struct time_info {
        uint64_t user_time_ms{0};   
        uint64_t kernel_time_ms{0}; 
        uint64_t wall_time_ms{0};   
    };

    enum class state {
        running,   
        suspended, 
        stopped,   
        exited,    
        unknown    
    };

    enum class permission {
        read = 0x01,       
        write = 0x02,      
        execute = 0x04,    
        terminate = 0x08,  
        query_info = 0x10, 
        all = 0xFF         
    };

    enum class privilege_level {
        privileged,     
        not_privileged, 
        unknown         
    };

    enum class elevation_tool {
        auto_, 
        sudo,  
        pkexec 
    };

    struct shell_result {
        int exit_code; 
        string output; 
    };
 
private:
    void reader_loop();
 
    void close_handles() noexcept;

    void detach_handles() noexcept;
 
    native_id_type process_id_{0}; 
    int exit_code_{-1};            
    bool started_{false};          
    bool finished_{false};         
 
    string work_dir_;                       
    vector<pair<string, string>> env_vars_; 
    bool capture_stdout_{false};            
    bool capture_stderr_{false};            
    string stdin_data_;                     
 
    string stdout_file_; 
    string stderr_file_; 
 
    pipe* external_stdin_pipe_{nullptr};  
    pipe* external_stdout_pipe_{nullptr}; 
    pipe* external_stderr_pipe_{nullptr}; 
 
    bool detached_{false}; 
 
    pipe stdout_pipe_; 
    pipe stderr_pipe_; 
    pipe stdin_pipe_;  
 
    string stdout_buf_; 
    string stderr_buf_; 
 
    thread reader_thread_;               
    atomic<bool> reader_running_{false}; 
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    void* process_handle_{nullptr}; 
    void* thread_handle_{nullptr};  
#endif
 
public:
    process() = default;

    ~process();
 
    process(const process&) = delete;
    process& operator=(const process&) = delete;

    process(process&& other) noexcept;

    process& operator=(process&& other) noexcept;

    process& set_work_dir(const string& dir);

    process& set_env(const string& key, const string& value);

    process& set_capture_stdout(bool v = true);

    process& set_capture_stderr(bool v = true);

    process& set_stdin_data(const string& data);

    process& set_stdout_file(const string& file_path);

    process& set_stderr_file(const string& file_path);

    process& set_external_stdin(pipe& external_pipe);

    process& set_external_stdout(pipe& external_pipe);

    process& set_external_stderr(pipe& external_pipe);

    static void chain(process& first, process& second);

    static void chain(vector<process*>& processes);

    void start(const string& executable, const vector<string>& args = {});

    void start_elevated(const string& executable, const vector<string>& args = {},
                        elevation_tool tool = elevation_tool::auto_);

    int wait(int timeout_ms = -1);

    void terminate();

    void suspend();

    void resume();

    void close() noexcept;

    NEFORCE_NODISCARD bool is_running() const;

    NEFORCE_NODISCARD state get_state() const;

    NEFORCE_NODISCARD memory_info get_memory_info() const;

    NEFORCE_NODISCARD native_id_type id() const noexcept { return process_id_; }

    NEFORCE_NODISCARD int exit_code() const noexcept { return exit_code_; }

    NEFORCE_NODISCARD const string& stdout_output() const noexcept { return stdout_buf_; }

    NEFORCE_NODISCARD const string& stderr_output() const noexcept { return stderr_buf_; }

    void write_stdin(const string& data);

    void close_stdin();

    NEFORCE_NODISCARD static shell_result execute_shell(const string& command, int timeout_ms = -1);

    static shell_result execute_elevated_shell(const string& command, int timeout_ms = -1,
                                               elevation_tool tool = elevation_tool::auto_);

    static native_id_type spawn(const string& executable, const vector<string>& args = {});

    static int system(const string& executable, const vector<string>& args = {}, int timeout_ms = -1);

    static string capture(const string& executable, const vector<string>& args = {}, int timeout_ms = -1);

    NEFORCE_NODISCARD static native_id_type current_id() noexcept;

    NEFORCE_NODISCARD static privilege_level current_privilege_level() noexcept;

    NEFORCE_NODISCARD static string name(native_id_type process_id);

    NEFORCE_NODISCARD static memory_info get_memory_info(native_id_type process_id);

    NEFORCE_NODISCARD static state get_state(native_id_type process_id);

    NEFORCE_NODISCARD static privilege_level get_privilege_level(native_id_type process_id);

    NEFORCE_NODISCARD static bool check_permission(native_id_type process_id, permission permission);

    NEFORCE_NODISCARD static string search_path(const string& executable);
};
 // Process
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_PROCESS_HPP__