boruta

type AccessInfo struct {
	// Addr is necessary information to connect to a tunnel to Dryad.
	Addr net.Addr
	// Key is private RSA key of the job session.
	Key rsa.PrivateKey
	// Username is a login name for the job session.
	Username string
}

type Capabilities map[string]string

type Dryad interface {
	// PutInMaintenance prepares MuxPi for administrative action.
	// It blinks LEDs, prints msg on the OLED display, etc.
	PutInMaintenance(msg string) (err error)
	// Prepare creates appropriate user, generates SSH keypair, installs public key
	// so that it can be used for SSH authentication and returns private key.
	// It removes current instance of the user, etc.
	Prepare(key *ssh.PublicKey) (err error)
	// Healthcheck tests Dryad for system state, STM functions and state on MuxPi.
	// It may cause Dryad to call SetFail of Worker interface if the problem detected is critical.
	Healthcheck() (err error)
}

type Group = string

type Groups []Group

type JobInfo struct {
	// WorkerUUID identifies worker that runs the job.
	WorkerUUID WorkerUUID
	// Timeout after which this Job will be terminated.
	Timeout time.Time
}

type ListDirection bool

type ListFilter interface {
	// Match tells if element matches the filter.
	Match(elem interface{}) bool
}

type ListInfo struct {
	// TotalItems contains information how many items in total is in filtered collection.
	TotalItems uint64
	// RemainingItems contains information how many items are left till the end of colleciton
	// (when paginating).
	RemainingItems uint64
}

type NotFoundError string

type Priority uint8

type ReqID uint64

type ReqInfo struct {
	ID       ReqID
	Priority Priority
	// Owner is the User who created the Request.
	Owner UserInfo
	// Deadline is a time after which a Request's State will be set to TIMEOUT
	// if it had not been fulfilled.
	Deadline time.Time
	// ValidAfter is a time before which a Request will not be executed.
	ValidAfter time.Time
	State      ReqState
	Job        *JobInfo
	// Caps are the Worker capabilities required by the Request.
	Caps Capabilities
}

type ReqState string

type Requests interface {
	// NewRequest creates a Request with given features and adds it to the Queue.
	// It returns ID of the created Request.
	NewRequest(caps Capabilities, priority Priority, owner UserInfo,
		validAfter time.Time, deadline time.Time) (ReqID, error)
	// CloseRequest sets the Request's State to CANCEL (removes from the Queue)
	// or DONE (finishes the Job).
	CloseRequest(reqID ReqID) error
	// UpdateRequest modifies existing request. Request can be modified only
	// when it is in WAIT state.
	UpdateRequest(reqInfo *ReqInfo) error
	// GetRequestInfo returns ReqInfo associated with ReqID.
	GetRequestInfo(reqID ReqID) (ReqInfo, error)
	// ListRequests returns slice of ReqInfo matching the filter (any request matches if filter
	// is empty or nil).  Returned requests are sorted by given sorter. Matching requests are
	// divided into pages according to paginator and paginator specified page is returned.
	// Additional metadata are returned as a pointer to ListInfo.
	ListRequests(filter ListFilter, sorter *SortInfo, paginator *RequestsPaginator) ([]ReqInfo,
		*ListInfo, error)
	// AcquireWorker returns information necessary to access the Worker reserved by the Request
	// and prolongs access to it. If the Request is in the WAIT state, call to this function
	// will block until the state changes.
	// Users should use ProlongAccess() in order to avoid side-effects.
	AcquireWorker(reqID ReqID) (AccessInfo, error)
	// ProlongAccess sets the Job's Deadline to a predefined time.Duration from the time.Now().
	// It can be called multiple times, but is limited.
	ProlongAccess(reqID ReqID) error
}

type RequestsPaginator struct {
	// ID sets page border. When direction is set to forward the page will start with first
	// request after the ID and contain up to Limit items. If direction is set backward then
	// page contains up to Limit items before ID.
	ID ReqID
	// Direction in which list should be traversed.
	Direction ListDirection
	// Limit up to how many elements can be stored on one page.
	Limit uint16
}

type SortInfo struct {
	// Item by which collection should be sorted.
	Item string
	// Order in which collection should be sorted.
	Order SortOrder
}

type SortOrder bool

type Superviser interface {
	// Register adds a new Worker to the system in the MAINTENANCE state.
	// Capabilities are set on the Worker and can be changed by subsequent Register calls.
	// dryadAddress and sshAddress inform Superviser on address it should use to connect
	// using Go RPC and SSH respectively. They should parse to net.TCPAddr.
	Register(caps Capabilities, dryadAddress string, sshAddress string) (err error)
	// SetFail notifies the Server about the Failure of the Worker.
	// It can additionally contain non-empty reason of the failure.
	SetFail(uuid WorkerUUID, reason string) (err error)
}

type UserInfo struct {
	// Groups defines workers group that are accessible for user's requests.
	Groups Groups
}

type WorkerInfo struct {
	WorkerUUID WorkerUUID
	State      WorkerState
	Groups     Groups
	Caps       Capabilities
}

type WorkerState string

type WorkerUUID string

type Workers interface {
	// ListWorkers returns a slice of Workers matching filter (any worker matches if filter is
	// empty or nil. The list is sorted according to passed sorter (using default sorting when
	// it's nil). Matching workers are divided into pages according to paginator and paginator
	// specified page is returned. Additional metadata are returned as a pointer to ListInfo.
	ListWorkers(filter ListFilter, sorter *SortInfo, paginator *WorkersPaginator) ([]WorkerInfo,
		*ListInfo, error)
	// GetWorkerInfo returns WorkerInfo of specified worker.
	GetWorkerInfo(uuid WorkerUUID) (WorkerInfo, error)

	// SetState sets the Worker's state to either MAINTENANCE or IDLE.
	SetState(uuid WorkerUUID, state WorkerState) error
	// SetGroups updates the groups parameter of the Worker.
	SetGroups(uuid WorkerUUID, groups Groups) error
	// Deregister removes the Worker from the system.
	// It can only succeed if the Worker is in the MAINTENANCE mode.
	Deregister(uuid WorkerUUID) error
}

type WorkersPaginator struct {
	// ID sets page border. When direction is set to forward the page will start with first
	// workes after the ID and contain up to Limit items. If direction is set backward then
	// page contains up to Limit items before ID.
	ID WorkerUUID
	// Direction in which list should be traversed.
	Direction ListDirection
	// Limit up to how many elements can be stored on one page.
	Limit uint16
}