envexec

type Cmd struct {
	Environment Environment

	// file contents to copyin before exec
	CopyIn map[string]File

	// symbolic link to be created before exec
	SymLinks map[string]string

	// exec argument, environment
	Args []string
	Env  []string

	// Files for the executing command
	Files []File
	TTY   bool // use pty as input / output

	// resource limits
	TimeLimit        time.Duration
	MemoryLimit      Size
	StackLimit       Size
	ExtraMemoryLimit Size
	OutputLimit      Size
	ProcLimit        uint64
	OpenFileLimit    uint64
	CPURateLimit     uint64
	CPUSetLimit      string

	// Waiter is called after cmd starts and it should return
	// once time limit exceeded.
	// return true to as TLE and false as normal exits (context finished)
	Waiter func(context.Context, Process) bool

	// file names to copyout after exec
	CopyOut    []CmdCopyOutFile
	CopyOutMax Size // file size limit

	// CopyOutDir specifies a dir to dump all /w content
	CopyOutDir string

	// additional memory option
	AddressSpaceLimit bool
	DataSegmentLimit  bool
}

type CmdCopyOutFile struct {
	Name     string // Name is the file out to copyOut
	Optional bool   // Optional ignores the file if not exists
}

type Environment interface {
	Execve(context.Context, ExecveParam) (Process, error)
	WorkDir() *os.File // WorkDir returns opened work directory, should not close after
	// Open open file at work dir with given relative path and flags
	Open(path string, flags int, perm os.FileMode) (*os.File, error)
	// Make dir creates directory inside the container
	MkdirAll(path string, perm os.FileMode) error
	// Make symbolic link for a file / directory
	Symlink(oldName, newName string) error
}

type ExecveParam struct {
	// Args holds command line arguments
	Args []string

	// Env specifies the environment of the process
	Env []string

	// Files specifies file descriptors for the child process
	Files []uintptr

	// ExecFile specifies file descriptor for executable file using fexecve
	ExecFile uintptr

	// TTY specifies whether to use TTY
	TTY bool

	// Process Limitations
	Limit Limit
}

type File interface {
	// contains filtered or unexported methods
}

type FileCollector struct {
	Name  string
	Limit Size
	Pipe  bool
}

type FileError struct {
	Name    string        `json:"name"`
	Type    FileErrorType `json:"type"`
	Message string        `json:"message,omitempty"`
}

type FileErrorType int

type FileInput struct {
	Path string
}

type FileOpened struct {
	File *os.File
}

type FileReader struct {
	Reader io.Reader
	Stream bool
}

type FileStreamIn interface {
	File
	io.WriteCloser
	SetSize(*TerminalSize) error
}

type FileStreamOut interface {
	File
	io.ReadCloser
}

type FileWriter struct {
	Writer io.Writer
	Limit  Size
}

type Group struct {
	// Cmd defines Cmd running in parallel in multiple environments
	Cmd []*Cmd

	// Pipes defines the potential mapping between Cmd.
	// ensure nil is used as placeholder in correspond cmd
	Pipes []Pipe

	// NewStoreFile defines interface to create stored file
	NewStoreFile NewStoreFile
}

type Limit struct {
	Time         time.Duration // Time limit
	Memory       Size          // Memory limit
	Proc         uint64        // Process count limit
	Stack        Size          // Stack limit
	Output       Size          // Output limit
	Rate         uint64        // CPU Rate limit
	OpenFile     uint64        // Number of open files
	CPUSet       string        // CPU set limit
	DataSegment  bool          // Use stricter memory limit (e.g. rlimit)
	AddressSpace bool          // rlimit address space
}

type NewStoreFile func() (*os.File, error)

type Pipe struct {
	// In, Out defines the pipe input source and output destination
	In, Out PipeIndex

	// Name defines copy out entry name if it is not empty and proxy is enabled
	Name string

	// Limit defines maximum bytes copy out from proxy and proxy will still
	// copy data after limit exceeded
	Limit Size

	// Proxy creates 2 pipe and connects them by copying data
	Proxy bool
}

type PipeIndex struct {
	Index int
	Fd    int
}

type Process interface {
	Done() <-chan struct{} // Done returns a channel for wait process to exit
	Result() RunnerResult  // Result wait until done and returns RunnerResult
	Usage() Usage          // Usage retrieves the process usage during the run time
}

type Result struct {
	Status Status

	ExitStatus int

	Error string // error

	Time     time.Duration
	RunTime  time.Duration
	Memory   Size   // byte
	ProcPeak uint64 // maximum processes ever running

	// Files stores copy out files
	Files map[string]*os.File

	// FileError stores file errors details
	FileError []FileError
}

type RunnerResult = runner.Result

type Single struct {
	// Cmd defines Cmd running in parallel in multiple environments
	Cmd *Cmd

	// NewStoreFile defines interface to create stored file
	NewStoreFile NewStoreFile
}

type Size = runner.Size

type Status int

type TerminalSize struct {
	Rows uint16 // ws_row: Number of rows (in cells).
	Cols uint16 // ws_col: Number of columns (in cells).
	X    uint16 // ws_xpixel: Width in pixels.
	Y    uint16 // ws_ypixel: Height in pixels.
}

type Usage struct {
	Time   time.Duration
	Memory Size
}