dukkha

package
v0.5.2 Latest Latest
Warning

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

 Go to latest Published: Nov 21, 2021 License: Apache-2.0 Imports: 22 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var GlobalInterfaceTypeHandler rs.InterfaceTypeHandler = globalTypeManager

Functions

func RegisterRenderer 

func RegisterRenderer(name string, create RendererCreateFunc)

RegisterRenderer associates a renderer factory with name

func RegisterTask 

func RegisterTask(k ToolKind, tk TaskKind, create TaskCreateFunc)

RegisterTask associates a task factory with task kind

func RegisterTool 

func RegisterTool(k ToolKind, create ToolCreateFunc)

RegisterTool associates a tool factory with tool kind

func ResolveEnv 

func ResolveEnv(ctx RenderingContext, parent rs.Field, envFieldName, envTagName string) error

ResolveEnv resolve struct field with `Env` type in struct parent and add these env entries to ctx during resolving, so later entries can rely on former entries' value

NOTE: parent should be initialized with rs.Init before calling this function

Types

type ConfigResolvingContext 

type ConfigResolvingContext interface {
	Context

	ShellManager
	ToolManager
	TaskManager
	RendererManager

	// values
	RendererCacheDir(name string) string
	SetCacheDir(dir string)
	OverrideDefaultGitBranch(branch string)
}

func NewConfigResolvingContext 

func NewConfigResolvingContext(
	parent context.Context,
	ifaceTypeHandler rs.InterfaceTypeHandler,
	globalEnv map[string]utils.LazyValue,
) ConfigResolvingContext

type Context 

type Context interface {
	TaskExecContext

	SetRuntimeOptions(opts RuntimeOptions)
	RunTask(ToolKey, TaskKey) error
}

Context for user facing tasks

type Env 

type Env []*EnvEntry

Env is a list of name/value pairs (ordered)

func (Env) Clone 

func (orig Env) Clone() Env

Clone makes a copy of all env values without doing BaseField initialization

type EnvEntry 

type EnvEntry struct {
	rs.BaseField `yaml:"-" json:"-"`

	// Name of the entry (in other words, key)
	Name string `yaml:"name"`

	// Value associated to the name
	Value string `yaml:"value"`
}

EnvEntry is a single name/value pair

type EnvValues 

type EnvValues interface {
	GlobalEnvValues

	SetMatrixFilter(*matrix.Filter)
	MatrixFilter() *matrix.Filter

	MatrixArch() string
	MatrixKernel() string
	MatrixLibc() string

	AddEnv(override bool, env ...*EnvEntry)
	AddListEnv(env ...string)
}

type ExecSpecGetFunc 

type ExecSpecGetFunc func(toExec []string, isFilePath bool) (env Env, cmd []string, err error)

type ExecValues 

type ExecValues interface {
	SetOutputPrefix(s string)
	OutputPrefix() string

	SetTaskColors(prefixColor, outputColor termenv.Color)
	PrefixColor() termenv.Color
	OutputColor() termenv.Color

	CurrentTool() ToolKey
	CurrentTask() TaskKey

	SetTask(k ToolKey, tK TaskKey)

	TranslateANSIStream() bool
	RetainANSIStyle() bool
	ColorOutput() bool
	FailFast() bool
	ClaimWorkers(n int) int

	SetState(s TaskExecState)
	State() TaskExecState
}

type GlobalEnvValues added in v0.5.1 

type GlobalEnvValues interface {
	WorkingDir() string
	CacheDir() string

	GitBranch() string
	GitWorkTreeClean() bool
	GitTag() string
	GitDefaultBranch() string
	GitCommit() string

	HostKernel() string
	HostKernelVersion() string
	HostArch() string
	HostOS() string
	HostOSVersion() string
}

type IfaceFactory added in v0.4.3 

type IfaceFactory struct {
	Factories []*IfaceFactoryImpl
}

nolint:revive

type IfaceFactoryFunc added in v0.4.3 

type IfaceFactoryFunc func(subMatches []string) interface{}

nolint:revive

type IfaceFactoryImpl added in v0.4.3 

type IfaceFactoryImpl struct {
	// Name is the raw information about what instance we are creating
	// currently only used in json schema generation
	Name string

	Create IfaceFactoryFunc
	// contains filtered or unexported fields
}

nolint:revive

type IfaceTypeKey added in v0.4.3 

type IfaceTypeKey struct {
	Typ reflect.Type
}

nolint:revive

type Renderer 

type Renderer interface {
	rs.Field

	// Init the renderer and add itself to the context
	Init(ctx ConfigResolvingContext) error

	RenderYaml(rc RenderingContext, rawData interface{}, attributes []RendererAttribute) (result []byte, err error)
}

Renderer to handle rendering suffix

type RendererAttribute added in v0.5.0 

type RendererAttribute string

type RendererCreateFunc 

type RendererCreateFunc func(name string) Renderer

type RendererManager 

type RendererManager interface {
	AllRenderers() map[string]Renderer
	AddRenderer(name string, renderer Renderer)
}

RendererManager to manage renderers

type RenderingContext 

type RenderingContext interface {
	context.Context
	expand.Environ
	rs.InterfaceTypeHandler
	rs.RenderingHandler
	EnvValues

	// AddValues will merge provided values into existing values
	AddValues(values map[string]interface{}) error

	Env() map[string]utils.LazyValue

	Values() map[string]interface{}
}

type ReplaceEntries 

type ReplaceEntries map[string]*ReplaceEntry

type ReplaceEntry 

type ReplaceEntry struct {
	Data []byte
	Err  error
}

type Resolvable added in v0.5.0 

type Resolvable interface {
	rs.Field

	// DoAfterFieldsResolved is a helper function to ensure no data race
	//
	// The implementation MUST be safe to be used concurrently
	DoAfterFieldsResolved(
		rc RenderingContext,
		depth int,
		resolveEnv bool,
		do func() error,
		tagNames ...string,
	) error
}

Resolvable represents a kind of struct that can be resolved at runtime

type RunTaskOrRunCmd 

type RunTaskOrRunCmd interface{}

one of `tools.TaskExecRequest`, `[]dukkha.TaskExecSpec`

type RuntimeOptions added in v0.4.0 

type RuntimeOptions struct {
	FailFast            bool
	ColorOutput         bool
	TranslateANSIStream bool
	RetainANSIStyle     bool
	Workers             int
}

RuntimeOptions for task execution

type Shell 

type Shell interface {
	rs.Field

	GetExecSpec(toExec []string, isFilePath bool) (env Env, cmd []string, err error)
}

type ShellManager 

type ShellManager interface {
	AddShell(name string, impl Shell)
}

type ShellUser 

type ShellUser interface {
	GetShell(name string) (Shell, bool)
	AllShells() map[string]Shell
}

type Task 

type Task interface {
	Resolvable

	// ToolKind is the tool managing this task (e.g. docker)
	ToolKind() ToolKind

	// ToolName it the name of the tool this task belongs to
	ToolName() ToolName

	// Kind of the task (e.g. build)
	Kind() TaskKind

	// Name of the task (e.g. foo)
	Name() TaskName

	// Key is the composite key of tool and task key this task
	Key() TaskKey

	// GetMatrixSpecs for matrix execution
	//
	// The implementation MUST be safe to be used concurrently
	GetMatrixSpecs(rc RenderingContext) ([]matrix.Entry, error)

	// GetExecSpecs generate commands using current field values
	//
	// The implementation MUST be safe to be used concurrently
	GetExecSpecs(rc TaskExecContext, options TaskMatrixExecOptions) ([]TaskExecSpec, error)

	// GetHookExecSpecs generate hook run target
	//
	// The implementation MUST be safe to be used concurrently
	GetHookExecSpecs(ctx TaskExecContext, state TaskExecStage) ([]TaskExecSpec, error)
}

Task implementation requirements

type TaskCreateFunc 

type TaskCreateFunc func(toolName string) Task

type TaskExecContext 

type TaskExecContext interface {
	context.Context

	RenderingContext
	ShellUser
	ToolUser
	TaskUser

	DeriveNew() Context
	Cancel()

	// WithCustomParent divert from current context.Context
	// intended to be only used for defered `after` hooks
	WithCustomParent(parent context.Context) TaskExecContext

	ExecValues
}

type TaskExecOptions 

type TaskExecOptions interface {
	NextMatrixExecOptions() TaskMatrixExecOptions
}

func CreateTaskExecOptions 

func CreateTaskExecOptions(id, totalMatrix int) TaskExecOptions

type TaskExecSpec 

type TaskExecSpec struct {
	// StdoutAsReplace to replace same string in following TaskExecSpecs
	// use output to stdout of this exec
	StdoutAsReplace string

	// ShowStdout when StdoutAsReplace is set
	ShowStdout bool

	FixStdoutValueForReplace func(data []byte) []byte

	// StderrAsReplace to replace same string in following TaskExecSpecs
	// use output to stderr of this exec
	StderrAsReplace string

	// ShowStderr when StderrAsReplace is set
	ShowStderr bool

	FixStderrValueForReplace func(data []byte) []byte

	Chdir string

	// EnvSuggest to provide environment variables when not set by user
	EnvSuggest Env
	// EnvOverride to override existing environment variables
	EnvOverride Env

	Command []string

	AlterExecFunc func(
		replace ReplaceEntries,
		stdin io.Reader, stdout, stderr io.Writer,
	) (RunTaskOrRunCmd, error)

	Stdin io.Reader

	// IgnoreError to ignore error generated after running this spec
	// this option applies to all sub specs (as returned in AlterExecFunc)
	IgnoreError bool

	// UseShell if true, write command to local script cache
	// and execute with the target shell (as referenced by ShellName)
	UseShell bool

	// ShellName to reference a shell to execute command
	// when `UseShell` is true
	//
	// the availability of the shells denpends on `shells` in dukkha config
	// a special shell name is `embedded`, which will use the built-in shell
	// for command evaluation
	ShellName string
}

TaskExecSpec is the specification

type TaskExecStage 

type TaskExecStage uint8
const (
	StageBefore TaskExecStage = iota + 1

	StageBeforeMatrix
	StageAfterMatrixSuccess
	StageAfterMatrixFailure
	StageAfterMatrix

	StageAfterSuccess
	StageAfterFailure
	StageAfter
)

func (TaskExecStage) String 

func (s TaskExecStage) String() string

type TaskExecState added in v0.5.0 

type TaskExecState int
const (
	TaskExecPending TaskExecState = iota
	TaskExecNotStarted
	TaskExecWorking
	TaskExecSucceeded
	TaskExecFailed
	TaskExecCanceled
)

type TaskKey 

type TaskKey struct {
	Kind TaskKind
	Name TaskName
}

func (TaskKey) String 

func (k TaskKey) String() string

type TaskKind 

type TaskKind string

type TaskManager 

type TaskManager interface {
	AddToolSpecificTasks(kind ToolKind, name ToolName, tasks []Task)
}

type TaskMatrixExecOptions 

type TaskMatrixExecOptions interface {
	ID() int

	Total() int

	Seq() int

	IsLast() bool
}

type TaskName 

type TaskName string

type TaskReference 

type TaskReference struct {
	ToolKind ToolKind
	ToolName ToolName
	TaskKind TaskKind
	TaskName TaskName

	MatrixFilter *matrix.Filter
}

func ParseTaskReference 

func ParseTaskReference(taskRef string, defaultToolName ToolName) (*TaskReference, error)

ParseTaskReference parse task ref

<tool-kind>{:<tool-name>}:<task-kind>(<task-name>, ...)

e.g. buildah:build(dukkha) # use default matrix 

buildah:build(dukkha, {kernel: [linux]}) # use custom matrix
buildah:in-docker:build(dukkha, {kernel: [linux]}) # with tool-name

func (*TaskReference) TaskKey 

func (t *TaskReference) TaskKey() TaskKey

func (*TaskReference) ToolKey 

func (t *TaskReference) ToolKey() ToolKey

type TaskUser 

type TaskUser interface {
	GetToolSpecificTasks(k ToolKey) ([]Task, bool)
	AllToolSpecificTasks() map[ToolKey][]Task
}

type Tool 

type Tool interface {
	Resolvable

	// Kind of the tool, e.g. golang, docker
	Kind() ToolKind

	// Name of the tool, e.g. my-tool
	Name() ToolName

	// Key
	Key() ToolKey

	// GetCmd get cli command to run this tool
	GetCmd() []string

	GetTask(TaskKey) (Task, bool)

	AllTasks() map[TaskKey]Task

	Init(kind ToolKind, cachdDir string) error

	AddTasks(tasks []Task) error

	// Run task
	Run(taskCtx TaskExecContext, tsk TaskKey) error
}

Tool implementation requirements

type ToolCreateFunc 

type ToolCreateFunc func() Tool

type ToolKey 

type ToolKey struct {
	Kind ToolKind
	Name ToolName
}

func (ToolKey) String 

func (k ToolKey) String() string

type ToolKind 

type ToolKind string

type ToolManager 

type ToolManager interface {
	AddTool(k ToolKey, t Tool)
}

type ToolName 

type ToolName string

type ToolUser 

type ToolUser interface {
	AllTools() map[ToolKey]Tool
	GetTool(k ToolKey) (Tool, bool)
}

type TypeManager added in v0.4.3 

type TypeManager struct {
	// contains filtered or unexported fields
}

func (*TypeManager) Create added in v0.4.3 

func (h *TypeManager) Create(typ reflect.Type, yamlKey string) (interface{}, error)

Create implements rs.InterfaceTypeHandler

func (*TypeManager) Types added in v0.4.3 

func (h *TypeManager) Types() map[IfaceTypeKey]*IfaceFactory

Source Files

View all Source files

Directories

Path Synopsis

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.