juggler

type Component interface {
	// GetName returns the name of the component.
	GetName() string

	// GetDependencies returns all dependencies of the component.
	GetDependencies() []Component

	// IsEnabled returns if a component is enabled.
	IsEnabled() bool

	// Hooks returns the hooks for a component.
	Hooks() ComponentHooks

	// IsInstallable returns if a component is installable.
	// And if not, the error which describes why it is not installable.
	IsInstallable(ctx context.Context) (bool, error)
}

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

type ComponentEventType string

type ComponentHooks struct {
	PreUninstall func(ctx context.Context, c client.Client) error
	PreInstall   func(ctx context.Context, c client.Client) error
	PreUpdate    func(ctx context.Context, c client.Client) error
}

type ComponentObservation struct {
	ResourceExists bool
	ResourceHealthiness
}

type ComponentReconciler interface {
	// KnownTypes returns a list of component types that are supported by this reconciler.
	KnownTypes() []reflect.Type
	// Observe returns a ComponentObservation to return the state of a Component
	// inside the cluster to the ComponentReconciler
	Observe(ctx context.Context, component Component) (ComponentObservation, error)
	// Uninstall triggers an uninstall of a Component in the cluster
	Uninstall(ctx context.Context, component Component) error
	// Update updates a Component in the cluster
	Update(ctx context.Context, component Component) error
	// Install triggers an install of a Component in the cluster
	Install(ctx context.Context, component Component) error
	// PreUninstall calls the pre-uninstall hook of a Component.
	PreUninstall(ctx context.Context, component Component) error
	// PreUninstall calls the pre-install hook of a Component.
	PreInstall(ctx context.Context, component Component) error
	// PreUpdate calls the pre-update hook of a Component.
	PreUpdate(ctx context.Context, component Component) error
}

type ComponentResult struct {
	Component Component
	Result    ComponentStatus
	Message   string
}

type ComponentStatus struct {
	Name       string
	IsReady    bool
	EmitsEvent ComponentEventType
}

type EventRecorder interface {
	Event(eventtype EventType, reason, message string)

	// Eventf is just like Event, but with Sprintf for the message field.
	Eventf(eventtype EventType, reason, messageFmt string, args ...interface{})

	// AnnotatedEventf is just like eventf, but with annotations attached
	AnnotatedEventf(annotations map[string]string, eventtype EventType, reason, messageFmt string, args ...interface{})
}

type EventType string

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

type KeepOnUninstall interface {
	KeepOnUninstall() bool
}

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

type OrphanedComponentsDetector interface {
	// DetectOrphanedComponents searches for orphaned components. The `configuredComponents` contains a list of
	// configured components supported by the reconciler. It should be used to calculate the delta between
	// existing and configured components.
	// Orphaned=Existing\Configured (set difference D=M\N).
	DetectOrphanedComponents(ctx context.Context, configuredComponents []Component) ([]Component, error)
}

type ResourceHealthiness struct {
	Healthy bool
	Message string
}

type StatusVisibility interface {
	// IsStatusInternal method implemented by a component
	// indicates that the component is internal or external.
	IsStatusInternal() bool
}