worker

type CachedFile struct {
	FileID string
}

type Cmd struct {
	Args  []string
	Env   []string
	Files []CmdFile

	CPULimit      time.Duration
	ClockLimit    time.Duration
	MemoryLimit   Size
	StackLimit    Size
	OutputLimit   Size
	ProcLimit     uint64
	OpenFileLimit uint64
	CPURateLimit  uint64
	CPUSetLimit   string

	CopyIn   map[string]CmdFile
	Symlinks map[string]string

	CopyOut       []CmdCopyOutFile
	CopyOutCached []CmdCopyOutFile
	CopyOutMax    uint64
	CopyOutDir    string

	TTY               bool
	DataSegmentLimit  bool
	AddressSpaceLimit bool
}

type CmdCopyOutFile = envexec.CmdCopyOutFile

type CmdFile interface {
	// EnvFile prepares file for envexec file
	EnvFile(fs filestore.FileStore) (envexec.File, error)
	// Stringer to print debug information
	fmt.Stringer
}

type Collector struct {
	Name string       // pseudo name generated into copyOut
	Max  envexec.Size // max size to be collected
	Pipe bool
}

type Config struct {
	FileStore             filestore.FileStore
	EnvironmentPool       EnvironmentPool
	Parallelism           int
	WorkDir               string
	TimeLimitTickInterval time.Duration
	ExtraMemoryLimit      envexec.Size
	OutputLimit           envexec.Size
	CopyOutLimit          envexec.Size
	OpenFileLimit         uint64
	ExecObserver          func(Response)
}

type EnvironmentPool interface {
	Get() (envexec.Environment, error)
	Put(envexec.Environment)
	Destroy()
}

type FileError = envexec.FileError

type LocalFile struct {
	Src string
}

type MemoryFile struct {
	Content []byte
}

type PipeIndex = envexec.PipeIndex

type PipeMap = envexec.Pipe

type Request struct {
	RequestID   string
	Cmd         []Cmd
	PipeMapping []PipeMap
}

type Response struct {
	RequestID string
	Results   []Result
	Error     error
}

type Result struct {
	Status     envexec.Status
	ExitStatus int
	Error      string
	Time       time.Duration
	RunTime    time.Duration
	Memory     Size
	ProcPeak   uint64
	Files      map[string]*os.File
	FileIDs    map[string]string
	FileError  []FileError
}

type Size = envexec.Size

type Stat struct {
	Queue   int
	Running int
}

type Worker interface {
	Start()
	Submit(context.Context, *Request) (<-chan Response, <-chan struct{})
	Execute(context.Context, *Request) <-chan Response
	Stat() Stat
	Shutdown()
}