common

type ByteGenerator ¶

type ByteGenerator interface {
	GenerateBytes(charset string, n int) (b []byte, err error)
}

type ClusterType ¶

type ClusterType int64

const (
	Unknown ClusterType = iota
	OpenShift
	CNCF
)

func GetClusterType(ctx context.Context, k8sClient client.Client, cmName string) (clusterType ClusterType, err error)

func (ct ClusterType) String() string

type DeploymentName ¶

type DeploymentName string

const (
	PlatformIdentityProvider   DeploymentName = "platform-identity-provider"
	PlatformIdentityManagement DeploymentName = "platform-identity-management"
	PlatformAuthService        DeploymentName = "platform-auth-service"
)

type FallbackClient ¶

type FallbackClient struct {
	client.Client
	Reader client.Reader
}

FallbackClient implements client.Client, but will specifically read directly from the API server instead of the cache when a cache miss happens on an attempt to GET a particular object. Useful when there is a need to work around the cache's filters.

func (f *FallbackClient) Get(ctx context.Context, objkey client.ObjectKey, obj client.Object, opts ...client.GetOption) (err error)

type Finisher ¶

type Finisher interface {
	OnFinished(context.Context, client.Object, client.Object) error
}

Finisher is an interface that wraps the OnFinished method.

It takes a context assumed to be scoped to the current reconcile loop, the observed and generated client.Objects, and performs any work that needs to be done at the end of the subreconciler.

Returns an error if something goes wrong.

type GenerateFn ¶

type GenerateFn[T client.Object] func(SecondaryReconciler, context.Context, T) error

GenerateFn is a type of function used when a SecondaryReconciler supports creation of the secondary resource based upon various factors including settings on the primary resource, cluster observations, or other internal controller logic.

type Generator ¶

type Generator interface {
	Generate(context.Context, client.Object) error
}

Generator is an interface that wraps the Generate method.

It takes a context assumed to be scoped to the current reconcile loop and a client.Object that is the recipient of the new object state. It returns an error if something goes wrong over the course of performing this operation.

type Modifier ¶

type Modifier interface {
	Modify(context.Context, client.Object, client.Object) (bool, error)
}

Modifier is an interface that wraps the Modify method.

It takes a context assumed to be scoped to the current reconcile loop and two client.Object arguments - the first should be the observed object that represents what is on the cluster currently, and the second is what the reconciler determines should be installed on the cluster instead.

If there are relevant differences between the two objects, the first is updated with the values from the second so that they are now the same in those relevant ways.

Returns an bool representing whether a change was made to the first client.Object as well as an error if something goes wrong over the course of performing this operation.

type ModifyFn ¶

type ModifyFn[T client.Object] func(SecondaryReconciler, context.Context, T, T) (bool, error)

ModifyFn is a type of function used when a SecondaryReconciler supports modification of its secondary resource; this function is assumed to make modifications to the first of the two T arguments based upon the state in the second T argument and/or the behavior contained within the ModifyFn[T] itself.

type Named ¶

type Named interface {
	GetName() string
}

type Namespaced ¶

type Namespaced interface {
	GetNamespace() string
}

type ObjectKeyed ¶

type ObjectKeyed interface {
	Named
	Namespaced
}

ObjectKeyed is a convenience interface for deriving types.NamespacedNames, which are used as keys for Kubernetes client calls, from objects that already have their name and namespace set on them.

type OnFinishedFn ¶

type OnFinishedFn[T client.Object] func(SecondaryReconciler, context.Context, T, T) error

Finisher is a type of function used when a SecondaryReconciler is about to finish running.

type OnWriteFn ¶

type OnWriteFn[T client.Object] func(SecondaryReconciler, context.Context) error

OnWriteFn is a type of function used when a SecondaryReconciler either creates or updates its object on a cluster.

type RandomByteGenerator ¶

type RandomByteGenerator struct{}

func (g *RandomByteGenerator) GenerateBytes(charset string, n int) (b []byte, err error)

type RunModeType ¶

type RunModeType string

const (
	LocalRunMode   RunModeType = "local"
	ClusterRunMode RunModeType = "cluster"
)

type Secondary ¶

type Secondary interface {
	GetName() string               // returns the name of the implementer
	GetNamespace() string          // returns the namespace of the implementer
	GetEmptyObject() client.Object // returns an empty client.Object of the same type as the implementer
	GetPrimary() client.Object     // returns the object that is primary to this one
	GetKind() string               // returns the kind of the implementer
}

Secondary is used to denote a relationship between a primary object/resource and a secondary one.

type SecondaryReconciler ¶

type SecondaryReconciler interface {
	Secondary
	Subreconciler
	GetClient() client.Client
	Generator
	Modifier
	WriteResponder
	Finisher
}

SecondaryReconciler represents a secondary resource that needs to be created and/or modified alongside its related logic whenever its primary resource is being reconciled.

type SecondaryReconcilerBuilder ¶

type SecondaryReconcilerBuilder[T client.Object] struct {
	// contains filtered or unexported fields
}

func NewSecondaryReconcilerBuilder[T client.Object]() *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) Build() (*secondaryReconciler[T], error)

func (b *SecondaryReconcilerBuilder[T]) MustBuild() *secondaryReconciler[T]

func (b *SecondaryReconcilerBuilder[T]) WithClient(cl client.Client) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithGenerateFns(fns ...GenerateFn[T]) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithModifyFns(fns ...ModifyFn[T]) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithName(name string) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithNamespace(namespace string) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithOnFinishedFns(fns ...OnFinishedFn[T]) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithOnWriteFns(fns ...OnWriteFn[T]) *SecondaryReconcilerBuilder[T]

func (b *SecondaryReconcilerBuilder[T]) WithPrimary(primary client.Object) *SecondaryReconcilerBuilder[T]

type SecondaryReconcilerFn ¶

type SecondaryReconcilerFn subreconciler.Fn

SecondaryReconcilerFn is an adapter so that subreconciler.Fn's implement Subreconciler.

func NewSecondaryReconcilerFn(req ctrl.Request, fn subreconciler.FnWithRequest) SecondaryReconcilerFn

func (f SecondaryReconcilerFn) Reconcile(ctx context.Context) (result *ctrl.Result, err error)

type Subreconciler ¶

type Subreconciler interface {
	Reconcile(context.Context) (result *ctrl.Result, err error) // Reconcile is a subreconciler.Fn
}

Subreconciler represents a unit of what makes up the reconciliation of a given primary resource.

type Subreconcilers ¶

type Subreconcilers []Subreconciler

Subreconcilers implements Subreconciler

func (s Subreconcilers) Reconcile(ctx context.Context) (result *ctrl.Result, err error)

type WriteResponder ¶

type WriteResponder interface {
	OnWrite(context.Context) error
}

WriteResponder is an interface that wraps the OnWrite method.

It takes a context assumed to be scoped to the current reconcile loop and performs any work that needs to be done after a write is performed.

Returns an error if something goes wrong.