sandbox.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <atomic>
#include <filesystem>
#include <mutex>
#include <optional>
#include <string>
#include <vector>
 
namespace entropic {
 
struct SandboxInfo {
    std::filesystem::path path;       
    std::string delegation_id;        
    std::filesystem::path base_dir;   
};
 
struct SandboxResult {
    std::string patch;                                
    std::vector<std::filesystem::path> files_touched; 
    std::filesystem::path base_dir;                   
    std::filesystem::path head_dir;                   
};
 
class SandboxManager {
public:
    explicit SandboxManager(const std::filesystem::path& project_dir);
 
    ~SandboxManager();
 
    SandboxManager(SandboxManager&&) = default;
    SandboxManager& operator=(SandboxManager&&) = default;
    SandboxManager(const SandboxManager&) = delete;
    SandboxManager& operator=(const SandboxManager&) = delete;
 
    std::optional<SandboxInfo> create_sandbox(
        const std::string& delegation_id,
        std::optional<SandboxInfo> chain_from = std::nullopt);
 
    std::optional<SandboxResult> finalize_sandbox(const SandboxInfo& info);
 
    void discard_sandbox(const SandboxInfo& info);
 
    std::optional<std::filesystem::path> write_pending_patch(
        const std::string& delegation_id,
        const std::string& patch);
 
    const std::filesystem::path& project_dir() const;
 
    const std::filesystem::path& session_base() const;
 
    std::string next_delegation_id(const std::string& prefix);
 
private:
    bool ensure_base_snapshot();
 
    bool snapshot_tree(const std::filesystem::path& source,
                       const std::filesystem::path& target);
 
    bool path_in_session_base(const std::filesystem::path& p) const;
 
    void safe_remove(const std::filesystem::path& p);
 
    void prune_stale_sessions();
 
    std::filesystem::path project_dir_;   
    std::string session_id_;              
    std::filesystem::path session_base_;  
    std::filesystem::path base_dir_;      
    bool base_ready_ = false;             
    mutable std::mutex base_mutex_;
    std::atomic<unsigned> id_seq_{0};
};
 
class ScopedSandbox {
public:
    using SwapDirFn = void (*)(
        const std::string& session_key,
        const std::filesystem::path& path,
        bool entering, void* user_data);
 
    ScopedSandbox(SwapDirFn swap_fn,
                  void* user_data,
                  std::string session_key,
                  const std::filesystem::path& sandbox_path,
                  const std::filesystem::path& original_path);
 
    ~ScopedSandbox();
 
    ScopedSandbox(const ScopedSandbox&) = delete;
    ScopedSandbox& operator=(const ScopedSandbox&) = delete;
 
private:
    SwapDirFn swap_fn_;                   
    void* user_data_;                     
    std::string session_key_;             
    std::filesystem::path original_path_; 
};
 
} // namespace entropic