v1alpha1

package
v1.11.0-RC1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 9, 2020 License: Apache-2.0 Imports: 13 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	// SkipExecutionMessage will skip run command execution
	SkipExecutionMessage string = "will skip run command execution"
)

Variables

View Source 
var (
	ErrorNotSupportedCategory = errors.New("not supported category: invalid run command")
	ErrorNotSupportedAction   = errors.New("not supported action: invalid run command")
	ErrorInvalidCategory      = errors.New("invalid categories: invalid run command")
	ErrorEmptyCategory        = errors.New("missing categories: invalid run command")
)

These represents error messages

View Source 
var (
	// ErrorCanNotRunDueToFailedCondition is an error object that indicates that command could not be executed due to failed condition.
	ErrorCanNotRunDueToFailedCondition = errors.New("run condition failed: can not execute run command")
)

Functions

func HttpCommand 

func HttpCommand(c *RunCommand) *httpCommand

HttpCommand returns a new instance of httpCommand

func KVStore 

func KVStore(store map[string]interface{}) *kvStore

KVStore returns a new instance of kvStore

func Off 

func Off() bool

Off disables a runner instance

func On 

func On() bool

On enables a runner instance

func RunAlways 

func RunAlways() *runAlways

RunAlways returns a new instance of runAlways

func StoreCommand 

func StoreCommand(s BucketStorageCondition) *storeCommand

StoreCommand returns a new instance of storeCommand

func StoreCommandCondition 

func StoreCommandCondition(s BucketStorage, c RunCondition) *storeCommand

StoreCommandCondition returns a new instance of storeCommand

Types

type Bucket 

type Bucket interface {
	SetBucket(b string)
	IsBucketTaken(b string) bool
}

Bucket abstracts categorising run command results into specific bucket

type BucketStorage 

type BucketStorage interface {
	Bucket
	Storage
}

BucketStorage abstracts storing one or more run command results into buckets

type BucketStorageCondition 

type BucketStorageCondition interface {
	BucketStorage
	RunCondition
}

BucketStorageCondition abstracts saving of run command results and also abstracts the evaluation of whether the run command should get executed or skipped in the first place

type IDMapper 

type IDMapper interface {
	ID() string
	Map(id string, r *RunCommand)
}

IDMapper abstracts mapping of a RunCommand instance against an id

type Interface 

type Interface interface {
	IDMapper
	Runner
	RunCondition
}

Interface abstracts execution run command

type RunCommand 

type RunCommand struct {
	ID        string                 // uniquely identifies a run command
	WillRun   bool                   // flags if this run command should get executed or not
	Action    RunCommandAction       // represents the run command's action
	Category  RunCommandCategoryList // classification of run command
	Data      RunCommandDataMap      // input data required to execute run command
	Selects   SelectPaths            // paths whose values will be retrieved after run command execution
	*msg.Msgs                        // store and retrieve info, warns, errors, etc occurred during execution
}

RunCommand represent a run command

func Command 

func Command() *RunCommand

Command returns a new instance of RunCommand

func WithAction 

func WithAction(given *RunCommand, action RunCommandAction) (updated *RunCommand)

WithAction updates the given RunCommand instance with provided action

func WithCategory 

func WithCategory(given *RunCommand, category RunCommandCategory) (updated *RunCommand)

WithCategory updates the given RunCommand instance with provided category

func WithData 

func WithData(given *RunCommand, name string, d RunCommandData) (updated *RunCommand)

WithData updates the given RunCommand instance with provided input data

func WithSelect 

func WithSelect(given *RunCommand, paths []string) (updated *RunCommand)

WithSelect updates the given RunCommand instance with provided select paths

func (*RunCommand) AddError 

func (c *RunCommand) AddError(err error) (u *RunCommand)

AddError updates RunCommand instance with given error

func (*RunCommand) CreateAction 

func (c *RunCommand) CreateAction() (u *RunCommand)

CreateAction updates RunCommand instance with create action

func (*RunCommand) DeleteAction 

func (c *RunCommand) DeleteAction() (u *RunCommand)

DeleteAction updates RunCommand instance with delete action

func (*RunCommand) Enable 

func (c *RunCommand) Enable(p RunPredicate) (u *RunCommand)

Enable enables or disables execution of RunCommand instance based on the outcome of given predicate

func (*RunCommand) GetAction 

func (c *RunCommand) GetAction() (u *RunCommand)

GetAction updates RunCommand instance with get action

func (*RunCommand) IsRun 

func (c *RunCommand) IsRun() bool

IsRun flags if this run command will get executed or not

func (*RunCommand) ListAction 

func (c *RunCommand) ListAction() (u *RunCommand)

ListAction updates RunCommand instance with list action

func (*RunCommand) PatchAction 

func (c *RunCommand) PatchAction() (u *RunCommand)

PatchAction updates RunCommand instance with patch action

func (*RunCommand) PostAction 

func (c *RunCommand) PostAction() (u *RunCommand)

PostAction updates RunCommand instance with post action

func (*RunCommand) PutAction 

func (c *RunCommand) PutAction() (u *RunCommand)

PutAction updates RunCommand instance with put action

func (*RunCommand) Result 

func (c *RunCommand) Result(result interface{}) (r RunCommandResult)

Result is the name of method on RunCommand

func (*RunCommand) Run 

func (c *RunCommand) Run() (r RunCommandResult)

Run finds the specific run command implementation and executes the same

func (*RunCommand) SelfInfo 

func (c *RunCommand) SelfInfo() (me string)

SelfInfo returns this instance of RunCommand as a string format

func (*RunCommand) String 

func (c *RunCommand) String() string

func (*RunCommand) UpdateAction 

func (c *RunCommand) UpdateAction() (u *RunCommand)

UpdateAction updates RunCommand instance with update action

type RunCommandAction 

type RunCommandAction string

RunCommandAction determines the kind of action that gets executed by run task command 

const (
	// DeleteCommandAction represents a run command as a delete action
	DeleteCommandAction RunCommandAction = "delete"
	// CreateCommandAction represents a run command as a create action
	CreateCommandAction RunCommandAction = "create"
	// PostCommandAction represents a run command as a post action
	PostCommandAction RunCommandAction = "post"
	// GetCommandAction represents a run command as a get action
	GetCommandAction RunCommandAction = "get"
	// ListCommandAction represents a run command as a list action
	ListCommandAction RunCommandAction = "list"
	// PatchCommandAction represents a run command as a patch action
	PatchCommandAction RunCommandAction = "patch"
	// UpdateCommandAction represents a run command as a update action
	UpdateCommandAction RunCommandAction = "update"
	// PutCommandAction represents a run command as a put action
	PutCommandAction RunCommandAction = "put"
)

type RunCommandCategory 

type RunCommandCategory string

RunCommandCategory represents the category of the run command. It helps in determining the exact entity or feature this run command is targeting.

NOTE: 

A run command can have more than one categories to determine an entity

const (
	// JivaCommandCategory categorises the run command as jiva based
	JivaCommandCategory RunCommandCategory = "jiva"
	// CstorCommandCategory categorises the run command as cstor based
	CstorCommandCategory RunCommandCategory = "cstor"
	// VolumeCommandCategory categorises the run command as volume based
	VolumeCommandCategory RunCommandCategory = "volume"
	// PoolCommandCategory categorises the run command as pool based
	PoolCommandCategory RunCommandCategory = "pool"
	// HttpCommandCategory categorises the run command as http based
	HttpCommandCategory RunCommandCategory = "http"
	// SnapshotCommandCategory categorises the run command as snapshot based
	SnapshotCommandCategory RunCommandCategory = "snapshot"
)

type RunCommandCategoryList 

type RunCommandCategoryList []RunCommandCategory

RunCommandCategoryList represents a list of RunCommandCategory

func (RunCommandCategoryList) Contains 

func (l RunCommandCategoryList) Contains(given RunCommandCategory) (no bool)

Contains returns true if this list has the given category

func (RunCommandCategoryList) IsCstorSnapshot 

func (l RunCommandCategoryList) IsCstorSnapshot() (no bool)

IsCstorSnapshot returns true if this list has both cstor and snapshot as its category items

func (RunCommandCategoryList) IsCstorVolume 

func (l RunCommandCategoryList) IsCstorVolume() (no bool)

IsCstorVolume returns true if this list has both cstor and volume as its category items

func (RunCommandCategoryList) IsEmpty 

func (l RunCommandCategoryList) IsEmpty() (empty bool)

IsEmpty returns true if no category is set

func (RunCommandCategoryList) IsHttpReq 

func (l RunCommandCategoryList) IsHttpReq() (no bool)

IsHttpReq returns true if this list points to a http based request

func (RunCommandCategoryList) IsJivaVolume 

func (l RunCommandCategoryList) IsJivaVolume() (no bool)

IsJivaVolume returns true if this list has both jiva and volume as its category items

func (RunCommandCategoryList) IsValid 

func (l RunCommandCategoryList) IsValid() (no bool)

IsValid returns true if category list is valid

TODO Move volume specific validations to volume command file

func (RunCommandCategoryList) String 

func (l RunCommandCategoryList) String() string

String implements Stringer interface

type RunCommandData 

type RunCommandData interface{}

RunCommandData represents data provided to the run command before its execution i.e. input data

type RunCommandDataMap 

type RunCommandDataMap map[string]RunCommandData

RunCommandDataMap represents a map of input data required to execute run command

func (RunCommandDataMap) String 

func (m RunCommandDataMap) String() string

String implements Stringer interface

type RunCommandMiddleware 

type RunCommandMiddleware func(given *RunCommand) (updated *RunCommand)

RunCommandMiddleware abstracts updating the given RunCommand instance

func CstorCategory 

func CstorCategory() RunCommandMiddleware

CstorCategory updates RunCommand instance with cstor as the run command's category

func HttpCategory 

func HttpCategory() RunCommandMiddleware

HttpCategory updates RunCommand instance with http as the run command's category

func JivaCategory 

func JivaCategory() RunCommandMiddleware

JivaCategory updates RunCommand instance with jiva as the run command's category

func Select 

func Select(paths []string) RunCommandMiddleware

Select updates the RunCommand instance with paths whose values will be extracted after execution of run command

func SnapshotCategory 

func SnapshotCategory() RunCommandMiddleware

SnapshotCategory updates RunCommand instance with snapshot as the runtask command's category

func VolumeCategory 

func VolumeCategory() RunCommandMiddleware

VolumeCategory updates RunCommand instance with volume as the run command's category

type RunCommandMiddlewareList 

type RunCommandMiddlewareList []RunCommandMiddleware

RunCommandMiddlewareList represents a list of RunCommandMiddleware

func (RunCommandMiddlewareList) Update 

func (l RunCommandMiddlewareList) Update(given *RunCommand) (updated *RunCommand)

Update updates the given RunCommand instance through all the middlewares

type RunCommandResult 

type RunCommandResult struct {
	Res    interface{} `json:"result"`          // result of run command execution
	Err    error       `json:"error"`           // root cause of issue; error if any during run command execution
	Extras msg.AllMsgs `json:"debug,omitempty"` // debug details i.e. errors, warnings, information, etc during execution
}

RunCommandResult holds the result and execution info of a run command

func NewRunCommandResult 

func NewRunCommandResult(result interface{}, extras msg.AllMsgs) (r RunCommandResult)

NewRunCommandResult returns a new RunCommandResult struct

func (RunCommandResult) Debug 

func (r RunCommandResult) Debug() msg.AllMsgs

Debug returns the debug info gathered during execution of run command's result

func (RunCommandResult) Error 

func (r RunCommandResult) Error() error

Error returns the error if any from the run command's result

func (RunCommandResult) GoString 

func (r RunCommandResult) GoString() string

GoString implements GoStringer interface

func (RunCommandResult) Result 

func (r RunCommandResult) Result() interface{}

Result returns the expected output if any from the run command's result

func (RunCommandResult) String 

func (r RunCommandResult) String() string

String implements Stringer interface

type RunCondition 

type RunCondition interface {
	WillRun() (condition string, willrun bool)
}

RunCondition abstracts evaluating the condition to run or skip executing a run command

type RunPredicate 

type RunPredicate func() bool

RunPredicate abstracts evaluation of executing or skipping execution of a runner instance

type Runner 

type Runner interface {
	Run() (r RunCommandResult)
}

Runner abstracts execution of command

type SelectPathAliasDelimiter 

type SelectPathAliasDelimiter string

SelectPathAliasDelimiter is used to delimit a select path from its alias

e.g.

".metadata.namespace as namespace" implies - '.metadata.namespace' is the path - ' as ' is the delimiter - 'namespace' is the alias 

const (
	// AsSelectDelimiter represents " as " as the delimiter
	AsSelectDelimiter SelectPathAliasDelimiter = " as "
)

type SelectPaths 

type SelectPaths []string

SelectPaths holds all the select paths specified in a run command

func (SelectPaths) QueryCommandResult 

func (s SelectPaths) QueryCommandResult(r RunCommandResult) (u RunCommandResult)

QueryCommandResult queries the run command's result based on the select paths

func (SelectPaths) String 

func (s SelectPaths) String() (str string)

String implements Stringer interface

type Storage 

type Storage interface {
	Store(key StoreKey, data interface{})
}

Storage abstracts saving run command results

type StoreKey 

type StoreKey string

StoreKey represents supported keys to store run command's execution results 

const (
	// ResultStoreKey stores the run commands results
	ResultStoreKey StoreKey = "result"
	//DebugStoreKey stores the debug results
	DebugStoreKey StoreKey = "debug"
	//ErrorStoreKey stores the errors after the run command
	ErrorStoreKey StoreKey = "error"
	//RootCauseStoreKey stores the rootCause of the errors
	RootCauseStoreKey StoreKey = "rootCause"
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.