plugin

type ChainError ¶

type ChainError struct {
	Message string
	Err     error
}

ChainError wraps an error that causes a PluginChain to fail.

func (e *ChainError) Error() string

func (e *ChainError) Unwrap() error

type CheckChain ¶

type CheckChain struct {
	Plugins    []CheckInstance
	Evaluable  gval.Evaluable
	Expression string
}

CheckChain represents a collection of multiple TriggerInstance that can be executed one after another.

func (chain *CheckChain) Execute(params Parameters) (CheckChainResult, error)

type CheckChainResult ¶ added in v1.0.0

type CheckChainResult struct {
	Passed     bool                   `json:"passed"`
	Info       map[string]CheckResult `json:"info"`
	Expression string                 `json:"expression"`
}

type CheckInstance ¶

type CheckInstance struct {
	Plugin Checker
	Name   string
}

CheckInstance represents a configured and named instance of a check plugin.

type CheckResult ¶ added in v1.0.0

type CheckResult struct {
	ID     string         `json:"id"`
	Passed bool           `json:"passed"`
	Info   map[string]any `json:"info"`
}

func Failed(info map[string]any) CheckResult

func FailedWithReason(reason string) CheckResult

func Passed(info map[string]any) CheckResult

func PassedWithReason(reason string) CheckResult

type Checker ¶

type Checker interface {
	Check(params Parameters) (CheckResult, error)
	New(config *ucfgwrap.Config) (Checker, error)
	ID() string
	// OnTransition is invoked once evaluation the CheckChain this instance is the cause for a transition.
	OnTransition(params Parameters) error
}

Checker is the interface that check plugins need to implement. Check plugins have to be idempotent, as they are invoked multiple times. A zero-initialized check plugin should not actually work as it is used to create the actual usable configured instances.

type InstanceDescriptor ¶

type InstanceDescriptor struct {
	Name   string
	Type   string
	Config *ucfg.Config
}

Specifies the configuration for a single check/trigger instance.

type InstancesDescriptor ¶

type InstancesDescriptor struct {
	Check   []InstanceDescriptor
	Notify  []NotificationDescriptor
	Trigger []InstanceDescriptor
}

Specifies the configuration for instances.

type NotificationChain ¶

type NotificationChain struct {
	Plugins []NotificationInstance
}

NotificationChain represents a collection of multiple NotificationInstance that can be executed one after another.

func (chain *NotificationChain) Execute(params Parameters) error

type NotificationData ¶

type NotificationData struct {
	// Technically state.NodeStateLabel, but that causes a cyclic import
	State string
	Time  time.Time
}

Data used to determine, whether to notify or not.

type NotificationDescriptor ¶

type NotificationDescriptor struct {
	Name     string
	Type     string
	Schedule ScheduleDescriptor `config:"schedule" validate:"required"`
	Config   *ucfg.Config
}

Specifies the configuration for a single notification instance.

type NotificationInstance ¶

type NotificationInstance struct {
	Plugin   Notifier
	Schedule Scheduler
	Name     string
}

NotificationInstance represents a configured and named instance of a notification plugin.

type Notifier ¶

type Notifier interface {
	Notify(params Parameters) error
	New(config *ucfgwrap.Config) (Notifier, error)
	ID() string
}

Notifier is the interface that notification plugins need to implement. It is recommend to make notification plugins idempotent, as the same message might be send multiple times. A zero-initialized notification plugin should not actually work as it is used to create the actual usable configured instances.

type NotifyOneshot ¶ added in v1.3.0

type NotifyOneshot struct {
	Delay time.Duration
}

func (no *NotifyOneshot) ShouldNotify(params ShouldNotifyParams) bool

type NotifyPeriodic ¶

type NotifyPeriodic struct {
	Interval time.Duration
}

Notifies on state changes and after passing the interval since the last notification if not the operational state.

func (np *NotifyPeriodic) ShouldNotify(params ShouldNotifyParams) bool

type NotifyScheduled ¶

type NotifyScheduled struct {
	Instant  time.Time
	Weekdays []time.Weekday
}

Notifies when the given instant passed on an allowed weekday.

func (ns *NotifyScheduled) ShouldNotify(params ShouldNotifyParams) bool

type Parameters ¶

type Parameters struct {
	// the current evaluated node
	Node *corev1.Node
	// the current state of the evaluated node
	State string
	// the profile that is currently evaluated
	Profile string
	// if any profile is in-maintenance on the evaluated node
	InMaintenance bool
	// whether to log failing checks, notifications, ...
	LogDetails     bool
	Client         client.Client
	Clientset      kubernetes.Interface
	Ctx            context.Context //nolint: containedctx
	Log            logr.Logger
	Recorder       record.EventRecorder
	LastTransition time.Time
}

Parameters describes the parameters plugins get to work with.

type Registry ¶

type Registry struct {
	NotificationInstances map[string]NotificationInstance
	NotificationPlugins   map[string]Notifier
	CheckInstances        map[string]CheckInstance
	CheckPlugins          map[string]Checker
	TriggerInstances      map[string]TriggerInstance
	TriggerPlugins        map[string]Trigger
}

Registry is a central storage for all plugins and their instances.

func NewRegistry() Registry

func (r *Registry) LoadInstances(config *ucfgwrap.Config, descriptor *InstancesDescriptor) error

func (r *Registry) NewCheckChain(config string) (CheckChain, error)

func (r *Registry) NewNotificationChain(config string) (NotificationChain, error)

func (r *Registry) NewTriggerChain(config string) (TriggerChain, error)

type ScheduleDescriptor ¶

type ScheduleDescriptor struct {
	Type   string
	Config *ucfg.Config
}

Specifies the configuration for a Scheduler.

type Scheduler ¶

type Scheduler interface {
	// Determines if a notification is required.
	ShouldNotify(params ShouldNotifyParams) bool
}

Interface notification schedulers need to implement.

type SchedulingLogger ¶ added in v0.17.0

type SchedulingLogger struct {
	Log        logr.Logger
	LogDetails bool
}

Used to log scheduling decisions.

type ShouldNotifyParams ¶ added in v1.3.0

type ShouldNotifyParams struct {
	Current     NotificationData
	Last        NotificationData
	StateChange time.Time
	Log         SchedulingLogger
}

type Trigger ¶

type Trigger interface {
	Trigger(params Parameters) error
	New(config *ucfgwrap.Config) (Trigger, error)
	ID() string
}

Trigger is the interface that trigger plugins need to implement. It is recommend to make trigger plugins idempotent, as the same trigger might be invoked multiple times. A zero-initialized trigger plugin should not actually work as it is used to create the actual usable configured instances.

type TriggerChain ¶

type TriggerChain struct {
	Plugins []TriggerInstance
}

TriggerChain represents a collection of multiple TriggerInstance that can be executed one after another.

func (chain *TriggerChain) Execute(params Parameters) error

type TriggerInstance ¶

type TriggerInstance struct {
	Plugin Trigger
	Name   string
}

TriggerInstance represents a configured and named instance of a trigger plugin.