controllers

type ClientSet ¶

type ClientSet interface {
	kubernetes.Interface
}

type DoguDeleteUseCase ¶ added in v3.14.0

type DoguDeleteUseCase interface {
	DoguUsecase
}

type DoguInstallOrChangeUseCase ¶ added in v3.14.0

type DoguInstallOrChangeUseCase interface {
	DoguUsecase
}

type DoguReconciler ¶ added in v3.14.0

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

The DoguReconciler knows where the [*doguv2.Dogu] is at all times. It knows this because it knows where it isn't. By subtracting where it is from where it isn't, or where it isn't from where it is (whichever is greater), it obtains a difference, or deviation. The guidance subsystem uses deviations to generate corrective commands to drive the [*doguv2.Dogu] from a position where it is to a position where it isn't, and arriving at a position where it wasn't, it now is. Consequently, the position where it is, is now the position that it wasn't, and it follows that the position that it was, is now the position that it isn't. In the event that the position that it is in is not the position that it wasn't, the system has acquired a variation, the variation being the difference between where the [*doguv2.Dogu] is, and where it wasn't. If variation is considered to be a significant factor, it too may be corrected by the GEA. However, the DoguReconciler must also know where the [*doguv2.Dogu] was. The [*doguv2.Dogu] guidance computer scenario works as follows. Because a variation has modified some of the information the [*doguv2.Dogu] has obtained, it is not sure just where it is. However, it is sure where it isn't, within reason, and it knows where it was. It now subtracts where it should be from where it wasn't, or vice-versa, and by differentiating this from the algebraic sum of where it shouldn't be, and where it was, it is able to obtain the deviation and its variation, which is called error.

func NewDoguReconciler(
	k8sClient client.Client,
	doguChangeHandler DoguInstallOrChangeUseCase,
	doguDeleteHandler DoguDeleteUseCase,
	doguInterface doguClientV2.DoguInterface,
	requeueHandler RequeueHandler,
	externalEvents <-chan event.TypedGenericEvent[*doguv2.Dogu],
	recorder record.EventRecorder,
	manager manager.Manager,
	config *config.OperatorConfig,
) (*DoguReconciler, error)

func (r *DoguReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

type DoguRestartGarbageCollector ¶

type DoguRestartGarbageCollector interface {
	DoGarbageCollection(ctx context.Context, doguName string) error
}

type DoguRestartReconciler ¶

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

DoguRestartReconciler reconciles a DoguRestart object

func NewDoguRestartReconciler(
	doguRestartInterface doguClientV2.DoguRestartInterface,
	doguInterface doguClientV2.DoguInterface,
	recorder record.EventRecorder,
	gc DoguRestartGarbageCollector,
	manager manager.Manager,
) (*DoguRestartReconciler, error)

func (r *DoguRestartReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

type DoguUsecase ¶ added in v3.14.0

type DoguUsecase interface {
	HandleUntilApplied(ctx context.Context, doguResource *v2.Dogu) (time.Duration, bool, error)
}

type GenericReconciler ¶ added in v3.14.0

type GenericReconciler interface {
	reconcile.Reconciler
	// contains filtered or unexported methods
}

type GlobalConfigReconciler ¶ added in v3.14.0

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

func NewGlobalConfigReconciler(
	doguInterface doguv2.DoguInterface,
	doguEvents chan<- event.TypedGenericEvent[*v2.Dogu],
	manager manager.Manager,
) (*GlobalConfigReconciler, error)

func (r *GlobalConfigReconciler) Reconcile(ctx context.Context, _ ctrl.Request) (ctrl.Result, error)

type K8sClient ¶

type K8sClient interface {
	client.Client
}

type RequeueHandler ¶ added in v3.14.0

type RequeueHandler interface {
	// Handle takes an error and handles the requeue process for the current dogu operation.
	Handle(ctx context.Context, doguResource *v2.Dogu, err error, reqTime time.Duration) (result ctrl.Result, requeueErr error)
}

requeueHandler abstracts the process to decide whether a requeue process should be done based on received errors.

type RestartOperation ¶

type RestartOperation string

func RestartOperationFromRestartStatusPhase(phase doguv2.RestartStatusPhase) RestartOperation

type WebhookServer ¶ added in v3.29.0

type WebhookServer interface {
	webhook.Server
}