controller

type Controller ¶

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

Controller runs a reconciliation loop to respond to changes in resources and their dependencies. It is heavily inspired by Kubernetes' controller pattern: https://kubernetes.io/docs/concepts/architecture/controller/

Use the builder methods in this package (starting with ForType) to construct a controller, and then pass it to a Manager to be executed.

func ForType(managedType *pbresource.Type) Controller

func (c Controller) String() string

func (c Controller) WithBackoff(base, max time.Duration) Controller

func (c Controller) WithLogger(logger hclog.Logger) Controller

func (c Controller) WithPlacement(placement Placement) Controller

func (c Controller) WithReconciler(reconciler Reconciler) Controller

func (c Controller) WithWatch(watchedType *pbresource.Type, mapper DependencyMapper) Controller

type DependencyMapper ¶

type DependencyMapper func(
	ctx context.Context,
	rt Runtime,
	res *pbresource.Resource,
) ([]Request, error)

DependencyMapper is called when a dependency watched via WithWatch is changed to determine which of the controller's managed resources need to be reconciled.

func MapOwnerFiltered(filter *pbresource.Type) DependencyMapper

func ReplaceType(desiredType *pbresource.Type) DependencyMapper

type Lease ¶

type Lease interface {
	// Held returns whether we are the current lease-holders.
	Held() bool

	// Changed returns a channel on which you can receive notifications whenever
	// the lease is acquired or lost.
	Changed() <-chan struct{}
}

Lease is used to ensure controllers are run as singletons (i.e. one leader- elected instance per cluster).

Currently, this is just an abstraction over Raft leadership. In the future, we'll build a backend-agnostic leasing system into the Resource Service which will allow us to balance controllers between many servers.

type Manager ¶

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

Manager is responsible for scheduling the execution of controllers.

func NewManager(client pbresource.ResourceServiceClient, logger hclog.Logger) *Manager

func (m *Manager) Register(ctrl Controller)

func (m *Manager) Run(ctx context.Context)

func (m *Manager) SetRaftLeader(leader bool)

type Placement ¶

type Placement int

Placement determines where and how many replicas of the controller will run.

const (
	// PlacementSingleton ensures there is a single, leader-elected, instance of
	// the controller running in the cluster at any time. It's the default and is
	// suitable for most use-cases.
	PlacementSingleton Placement = iota

	// PlacementEachServer ensures there is a replica of the controller running on
	// each server in the cluster. It is useful for cases where the controller is
	// responsible for applying some configuration resource to the server whenever
	// it changes (e.g. rate-limit configuration). Generally, controllers in this
	// placement mode should not modify resources.
	PlacementEachServer
)

func (p Placement) String() string

type Reconciler ¶

type Reconciler interface {
	// Reconcile the resource identified by req.ID.
	Reconcile(ctx context.Context, rt Runtime, req Request) error
}

Reconciler implements the business logic of a controller.

type Request ¶

type Request struct {
	// ID of the resource that needs to be reconciled.
	ID *pbresource.ID
}

Request represents a request to reconcile the resource with the given ID.

func MapOwner(_ context.Context, _ Runtime, res *pbresource.Resource) ([]Request, error)

func (r Request) Key() string

type RequeueAfterError ¶

type RequeueAfterError time.Duration

RequeueAfterError is an error that allows a Reconciler to override the exponential backoff behavior of the Controller, rather than applying the backoff algorithm, returning a RequeueAfterError will cause the Controller to reschedule the Request at a given time in the future.

func (r RequeueAfterError) Error() string

type Runtime ¶

type Runtime struct {
	Client pbresource.ResourceServiceClient
	Logger hclog.Logger
}

Runtime contains the dependencies required by reconcilers.