types

Documentation

Index

• Variables
• type Ack
• type CmdCook
• type CmdRun
• type CombinedVersion
• type CompletionStatus
• type CookSummary
• type EnvVar
• type Executor
• type FilePath
• type FileProvider
• type Function
• type Ingredient
• type Inline
• type Job
• type KeyManager
• type KeySet
• type KeySubmission
• type KeysByType
• type PingPong
• type RecipeCooker
• type RecipeEnvelope
• type RecipeName
• type ReqType
• type Requisite
  • func (r Requisite) Equals(other Requisite) bool
• type RequisiteSet
  • func (r RequisiteSet) AllIDs() []StepID
  • func (r RequisiteSet) AllSteps() []*Step
  • func (r RequisiteSet) Equals(other RequisiteSet) bool
• type Result
• type ServiceProvider
• type SimpleNote
  • func Snprintf(format string, a ...any) SimpleNote
  • func (s SimpleNote) String() string
• type SproutStepCompletion
• type Startup
• type Step
• type StepCompletion
• type StepID
• type Summary
• type TargetedAction
• type TargetedResults
• type Targets
• type TriggerMsg
• type Version

Variables

var (
	ErrAPIRouteNotFound     = errors.New("API Route not found")
	ErrAlreadyAccepted      = errors.New("this Sprout ID was already accepted")
	ErrAlreadyDenied        = errors.New("this Sprout ID was already denied")
	ErrAlreadyRejected      = errors.New("this Sprout ID was already rejected")
	ErrAlreadyUnaccepted    = errors.New("this Sprout ID was already unaccepted")
	ErrCannotParseRootCA    = errors.New("cannot load the RootCA certificate")
	ErrDependencyCycleFound = errors.New("found a dependency cycle")
	ErrSproutIDFound        = errors.New("a Sprout ID matching that system has already been recorded")
	ErrSproutIDInvalid      = errors.New("bad user input: invalid SproutID received")
	ErrSproutIDNotFound     = errors.New("a Sprout ID matching that system cannot be found")
	ErrInvalidUserInput     = errors.New("invalid user input was received")

	ErrNotImplemented           = errors.New("this feature is not yet implemented")
	ErrInvalidKeyState          = errors.New("code bug: an invalid key state was supplied")
	ErrConfirmationLengthIsZero = errors.New("code bug: confirmation options muct not be 0-length")

	ErrInvalidMethod  = errors.New("invalid method")
	ErrMissingName    = errors.New("recipe is missing a name")
	ErrMissingSource  = errors.New("recipe is missing a source")
	ErrMissingHash    = errors.New("file is missing a hash")
	ErrCacheFailure   = errors.New("file caching failed")
	ErrMissingContent = errors.New("file is missing content")

	ErrFileNotFound  = errors.New("file not found")
	ErrHashMismatch  = errors.New("file hash mismatch")
	ErrDeleteRoot    = errors.New("cannot delete root directory")
	ErrModifyRoot    = errors.New("cannot modify root directory")
	ErrMissingTarget = errors.New("target is missing")
	ErrPathNotFound  = errors.New("path not found")
)

Types

type Ack

type Ack struct {
	Acknowledged bool
	JobID        string
}

type CmdCook

type CmdCook struct {
	Async   bool          `json:"async"`
	Env     string        `json:"env"`
	Recipe  RecipeName    `json:"recipe"`
	Test    bool          `json:"test"`
	Timeout time.Duration `json:"timeout"`

	Errors map[string]error `json:"errors"`
	JID    string           `json:"jid"`
}

type CmdRun

type CmdRun struct {
	Command string        `json:"command"`
	Args    []string      `json:"args"`
	Path    string        `json:"path"` // path is prepended to the command's normal path
	CWD     string        `json:"cwd"`
	RunAs   string        `json:"runas"`
	Env     EnvVar        `json:"env"`
	Timeout time.Duration `json:"timeout"`

	Stdout   string        `json:"stdout"`
	Stderr   string        `json:"stderr"`
	Duration time.Duration `json:"duration"`
	ErrCode  int           `json:"errcode"`

	Error error `json:"error"`
}

type CombinedVersion

type CombinedVersion struct {
	CLI    Version `json:"cli"`
	Farmer Version `json:"farmer"`
	Error  string  `json:"error"`
}

type CompletionStatus

type CompletionStatus int

const (
	StepNotStarted CompletionStatus = iota
	StepInProgress
	StepCompleted
	StepFailed
)

type CookSummary

type CookSummary struct {
	Succeeded int
	Failures  int
	Changed   int
	Notes     []fmt.Stringer
}

type EnvVar

type EnvVar map[string]string

type Executor

type Executor struct {
	PubKey string
}

type FilePath

type FilePath struct {
	Name string `json:"name"`
}

type FileProvider

type FileProvider interface {
	Download(context.Context) error
	Properties() (map[string]interface{}, error)
	Parse(id, source, destination, hash string, properties map[string]interface{}) (FileProvider, error)
	Protocols() []string
	Verify(context.Context) (bool, error)
}

type Function

type Function string

type Ingredient

type Ingredient string

type Inline

type Inline struct {
	Success bool  `json:"success"`
	Error   error `json:"error"`
}

type Job

type Job struct {
	JID     string   `json:"jid"`
	ID      string   `json:"id"`
	Results []Result `json:"results"`
	Sprout  string   `json:"sprout"`
	Summary Summary  `json:"summary"`
}

type KeyManager

type KeyManager struct {
	SproutID string `json:"id"`
}

type KeySet

type KeySet struct {
	Sprouts []KeyManager `json:"sprouts"`
}

type KeySubmission

type KeySubmission struct {
	NKey     string `json:"nkey"`
	SproutID string `json:"id"`
}

type KeysByType

type KeysByType struct {
	Accepted   KeySet `json:"accepted,omitempty"`
	Denied     KeySet `json:"denied,omitempty"`
	Rejected   KeySet `json:"rejected,omitempty"`
	Unaccepted KeySet `json:"unaccepted,omitempty"`
}

type PingPong

type PingPong struct {
	Ping  bool  `json:"ping"`
	Pong  bool  `json:"pong"`
	Error error `json:"error"`
}

type RecipeCooker

type RecipeCooker interface {
	Apply(context.Context) (Result, error)
	Test(context.Context) (Result, error)
	Properties() (map[string]interface{}, error)
	Parse(id, method string, properties map[string]interface{}) (RecipeCooker, error)
	Methods() (string, []string)
	PropertiesForMethod(method string) (map[string]string, error)
}

type RecipeEnvelope

type RecipeEnvelope struct {
	JobID string
	Steps []Step
	Test  bool
}

type RecipeName

type RecipeName string

type ReqType

type ReqType string

const (
	OnChanges ReqType = "onchanges"
	OnFail    ReqType = "onfail"
	Require   ReqType = "require"

	OnChangesAny ReqType = "onchanges_any"
	OnFailAny    ReqType = "onfail_any"
	RequireAny   ReqType = "require_any"
)

type Requisite

type Requisite struct {
	Condition ReqType
	StepIDs   []StepID
	Steps     []*Step
}

func (Requisite) Equals

func (r Requisite) Equals(other Requisite) bool

type RequisiteSet

type RequisiteSet []Requisite

func (RequisiteSet) AllIDs

func (r RequisiteSet) AllIDs() []StepID

func (RequisiteSet) AllSteps

func (r RequisiteSet) AllSteps() []*Step

func (RequisiteSet) Equals

func (r RequisiteSet) Equals(other RequisiteSet) bool

type Result

type Result struct {
	Succeeded bool
	Failed    bool
	Changed   bool
	Notes     []fmt.Stringer
}

type ServiceProvider

type ServiceProvider interface {
	Properties() (map[string]interface{}, error)
	Parse(id, method string, properties map[string]interface{}) (ServiceProvider, error)

	Start(context.Context) error
	Stop(context.Context) error
	Status(context.Context) (string, error)

	Enable(context.Context) error
	Disable(context.Context) error
	IsEnabled(context.Context) (bool, error)

	IsRunning(context.Context) (bool, error)
	Restart(context.Context) error

	Mask(context.Context) error
	Unmask(context.Context) error
	IsMasked(context.Context) (bool, error)

	InitName() string
	IsInit() bool
}

type SimpleNote

type SimpleNote string

func Snprintf

func Snprintf(format string, a ...any) SimpleNote

func (SimpleNote) String

func (s SimpleNote) String() string

type SproutStepCompletion

type SproutStepCompletion struct {
	SproutID      string
	CompletedStep StepCompletion
}

type Startup

type Startup struct {
	Version  Version `json:"version"`
	SproutID string  `json:"id"`
}

type Step

type Step struct {
	Ingredient  Ingredient `json:"ingredient" yaml:"ingredient"`
	Method      string     `json:"method" yaml:"method"`
	ID          StepID
	Requisites  RequisiteSet
	Properties  map[string]interface{}
	IsRequisite bool
}

type StepCompletion

type StepCompletion struct {
	ID               StepID
	CompletionStatus CompletionStatus
	ChangesMade      bool
	Changes          []string
	Error            error
}

type StepID

type StepID string

type Summary

type Summary struct {
	Succeeded  int
	InProgress bool
	Failures   int
	Changes    int
	Errors     []error
}

type TargetedAction

type TargetedAction struct {
	Target []KeyManager `json:"target"`
	Action interface{}  `json:"action"`
}

type TargetedResults

type TargetedResults struct {
	Results map[string]interface{} `json:"results,omitempty"`
}

type Targets

type Targets []StepID

type TriggerMsg

type TriggerMsg struct {
	JID string `json:"jid"`
}

type Version

type Version struct {
	Arch      string `json:"arch"`
	Compiler  string `json:"compiler"`
	GitCommit string `json:"git_commit"`
	Tag       string `json:"tag"`
}