sandbox

type AuditLogEntry struct {
	Timestamp time.Time
	Action    string
	SandboxID SandboxID
	Status    string
	User      string
	Message   string
	Details   map[string]interface{}
}

type Config struct {
	DefaultQuota            ResourceQuota
	DefaultIsolationLevel   IsolationLevel
	EnableAudit             bool
	ContainerImage          string
	ResourceMonitorInterval time.Duration
	CleanupInterval         time.Duration
}

type Container interface {
	ID() string
	Start() error
	Stop() error
	Destroy() error
	Exec(cmd []string) ([]byte, error)
	Stats() (*ContainerStats, error)
}

type ContainerConfig struct {
	SandboxID    SandboxID         `json:"sandbox_id" yaml:"sandbox_id"`
	FeedID       string            `json:"feed_id" yaml:"feed_id"`
	Image        string            `json:"image" yaml:"image"`
	Command      []string          `json:"command" yaml:"command"`
	Environment  map[string]string `json:"environment" yaml:"environment"`
	Volumes      []string          `json:"volumes" yaml:"volumes"`
	NetworkMode  string            `json:"network_mode" yaml:"network_mode"`
	Resources    ResourceQuota     `json:"resources" yaml:"resources"`
	SecurityOpts []string          `json:"security_opts" yaml:"security_opts"`
}

type ContainerInfo struct {
	ID        string `json:"id" yaml:"id"`
	SandboxID string `json:"sandbox_id" yaml:"sandbox_id"`
	Status    string `json:"status" yaml:"status"`
}

type ContainerStats struct {
	CPU     float64 `json:"cpu" yaml:"cpu"`
	Memory  int64   `json:"memory" yaml:"memory"`
	Network int64   `json:"network" yaml:"network"`
	Disk    int64   `json:"disk" yaml:"disk"`
}

type ContainerSystem interface {
	// Create creates a new container
	Create(config *ContainerConfig) (Container, error)

	// Start starts a container
	Start(containerID string) error

	// Stop stops a container
	Stop(containerID string) error

	// Destroy destroys a container
	Destroy(containerID string) error

	// Pause pauses a container
	Pause(containerID string) error

	// Resume resumes a container
	Resume(containerID string) error

	// Exec executes a command in a container
	Exec(containerID string, cmd []string) ([]byte, error)

	// Stats returns container statistics
	Stats(containerID string) (*ContainerStats, error)

	// List lists all containers
	List() ([]ContainerInfo, error)
}

type FeedResult struct {
	FeedID    string
	Status    string
	Processed time.Time
	Errors    []string
}

type IsolationLevel string

type IsolationLevelValidator struct{}

type MissingFeedReference struct {
	FeedID string
}

type PolicyEngine struct {
	// contains filtered or unexported fields
}

type PolicyValidator interface {
	Validate(policy *SandboxPolicy) error
	Name() string
}

type ResourceQuota struct {
	CPU      int64   `json:"cpu" yaml:"cpu"`                     // MilliCPU units
	Memory   int64   `json:"memory" yaml:"memory"`               // Bytes
	Disk     int64   `json:"disk" yaml:"disk"`                   // Bytes
	Network  int64   `json:"network" yaml:"network"`             // Bytes per second
	Files    int64   `json:"files" yaml:"files"`                 // Maximum files
	Process  int64   `json:"process" yaml:"process"`             // Maximum processes
	Duration *string `json:"duration" yaml:"duration,omitempty"` // Max duration
}

type ResourceQuotaValidator struct{}

type ResourceUsage struct {
	CPU     int64 `json:"cpu" yaml:"cpu"`
	Memory  int64 `json:"memory" yaml:"memory"`
	Disk    int64 `json:"disk" yaml:"disk"`
	Network int64 `json:"network" yaml:"network"`
	Files   int64 `json:"files" yaml:"files"`
	Process int64 `json:"process" yaml:"process"`
}

type Sandbox struct {
	ID            SandboxID
	Policy        SandboxPolicy
	Status        SandboxStatus
	CreatedAt     time.Time
	StartedAt     time.Time
	StoppedAt     time.Time
	ResourceUsage ResourceUsage
}

type SandboxFactory struct {
	// contains filtered or unexported fields
}

type SandboxID string

type SandboxInfo struct {
	ID        SandboxID     `json:"id" yaml:"id"`
	Status    SandboxStatus `json:"status" yaml:"status"`
	PID       int           `json:"pid" yaml:"pid,omitempty"`
	StartedAt time.Time     `json:"started_at" yaml:"started_at,omitempty"`
	Resources ResourceUsage `json:"resources" yaml:"resources"`
	Uptime    time.Duration `json:"uptime" yaml:"uptime,omitempty"`
}

type SandboxManager interface {
	Create(id SandboxID, policy SandboxPolicy) (*Sandbox, error)
	Get(id SandboxID) (*Sandbox, error)
	Start(id SandboxID) error
	Stop(id SandboxID) error
	Destroy(id SandboxID) error
	List() ([]Sandbox, error)
	Stats() ([]SandboxStats, error)
}

type SandboxManagerConfig struct {
	DefaultIsolation IsolationLevel
	DefaultQuota     ResourceQuota
	EnableAudit      bool
	MaxSandboxes     int
}

type SandboxPolicy struct {
	ID             SandboxID       `json:"id" yaml:"id"`
	FeedID         string          `json:"feed_id" yaml:"feed_id"`
	Status         SandboxStatus   `json:"status" yaml:"status"`
	ResourceQuota  ResourceQuota   `json:"resource_quota" yaml:"resource_quota"`
	IsolationLevel IsolationLevel  `json:"isolation_level" yaml:"isolation_level"`
	SecurityPolicy *SecurityPolicy `json:"security_policy,omitempty" yaml:"security_policy,omitempty"`
	AuditLogging   bool            `json:"audit_logging" yaml:"audit_logging"`
	CreatedAt      time.Time       `json:"created_at" yaml:"created_at"`
	UpdatedAt      time.Time       `json:"updated_at" yaml:"updated_at"`
}

type SandboxProcessor struct {
	// contains filtered or unexported fields
}

type SandboxStats struct {
	SandboxID     SandboxID
	Status        SandboxStatus
	ResourceUsage ResourceUsage
	Uptime        time.Duration
}

type SandboxStatus string

type SecurityPolicy struct {
	NetworkIsolation bool     `json:"network_isolation" yaml:"network_isolation"`
	FileAccess       []string `json:"file_access" yaml:"file_access"`
	NetworkAccess    []string `json:"network_access" yaml:"network_access"`
	ProcessAccess    []string `json:"process_access" yaml:"process_access"`
	ResourceLimits   bool     `json:"resource_limits" yaml:"resource_limits"`
}

type ValidationError struct {
	Code      string
	Message   string
	Field     string
	Details   map[string]interface{}
	Timestamp time.Time
	FeedID    string
	DomainID  string
}