pipservices

type NamasepacesParams struct {
	Task string
	Lock string
}

type Namespaces interface {
	// Task return task namespace
	Task() (value string)
	// Lock return lock namespace
	Lock() (value string)
}

type NamespacesUnit interface {
	// FromScope return namespace from scope (or defaultNamespace if scope is undefined)
	FromScope(scp app.Scope, defaultNamespace Namespaces) (namespace Namespaces, err error)
	// DefineScope define scope namespaces
	Define(scp app.Scope, namspaces Namespaces) (err error)
	// Bind copy namespaces from parent scope to child scope
	Bind(parent, child app.Scope) (err error)
}

type Pip struct {
	Name        string
	Description string
	Context     PipContext
	Namespaces  Namespaces
	Sandbox     string
	Lock        commservices.LockMap
	Wait        []string
}

type PipContext struct {
	In    app.Input
	Out   app.Output
	Err   app.Output
	CWD   filesystem.Filespace
	Scope app.Scope
}

type Runner interface {
	Run(pip Pip) (err error)
}

type Sandbox interface {
	Run(ctx app.IOContext) (err error)
}

type SandboxBuilder interface {
	Is(name string) bool
	Build(name string) (sandbox Sandbox, err error)
}

type SandboxesManager interface {
	Add(sandboxsFactory SandboxBuilder)
	Get(name string) (sandbox Sandbox, err error)
}

type Task interface {
	// Name return task name
	Name() string
	// FullName return name with task namespace as prefix
	FullName() string
	// Description return task description
	Description() string
	// OBroadcast write task output (and error output) to broadcast
	OBroadcast() app.BufferedBroadcast
	// IOBroadcast write input, output and error output to broadcast
	IOBroadcast() app.BufferedBroadcast
	// Done return true if task is finished
	Done() bool
	// Status return task status description
	Status() string
	// Wait for task finish
	Wait() error
	// WaitList return list of related tasks to wait for
	WaitList() []string
	// WaitLockMapList return map described related resources to lock
	LockMap() commservices.LockMap
	// Errors return task errors (or nil)
	Errors() []error
}

type TaskWriter interface {
	Task
	// IOContext return task IOContext
	IOContext() app.IOContext
	// SetStatus set task status
	SetStatus(status string)
	// Close make task done
	Close() (err error)
}

type TasksManager interface {
	// OBroadcast write all tasks output logs to broadcast
	OBroadcast() app.BufferedBroadcast
	// StatusBroadcast write tasks statuses changes to broadcast
	StatusBroadcast() app.BufferedBroadcast
	// Summary write summary log to output
	Summary(out app.Output) (err error)
	// Names return tasks names
	Names() []string
	// Get task by name
	Get(name string) (task Task, ok bool)
	// Create new task from Pip
	Create(pip Pip) (task TaskWriter, err error)
	// Wait
	Wait() (err error)
}

type TasksUnit interface {
	FromScope(scp app.Scope) (tasks TasksManager, err error)
	BindScope(scp app.Scope, tasks TasksManager) (err error)
	Clear(scp app.Scope) (err error)
}