controllerutils

func DefaultActiveOperationPrioritizingCooldown ¶

func DefaultActiveOperationPrioritizingCooldown(activeOperationLister corelisters.ActiveOperationLister) *ActiveOperationBasedChecker

func NewActiveOperationPrioritizingCooldown ¶

func NewActiveOperationPrioritizingCooldown(activeOperationLister corelisters.ActiveOperationLister, activeOperationCooldown, inactiveOperationCooldown time.Duration) *ActiveOperationBasedChecker

func NewGenericOperationController ¶

func NewGenericOperationController(
	name string,
	synchronizer OperationSynchronizer,
	activeOperationScanInterval time.Duration,
	activeOperationInformer cache.SharedIndexInformer,
	resourcesDBClient corecosmosstorage.ResourcesDBClient,
) Controller

NewGenericOperationController returns a Controller that updates Cosmos DB documents tracking ongoing asynchronous operations. Each Controller instance has a unique OperationSynchronizer that reconciles a particular type of asynchronous operation, like cluster creation or node pool deletion.

func NewClusterWatchingController ¶

func NewClusterWatchingController(
	name string,
	resourcesDBClient corecosmosstorage.ResourcesDBClient,
	informers coreinformers.BackendInformers,
	kubeApplierInformers *unionkubeapplierinformers.UnionKubeApplierInformers,
	resyncDuration time.Duration,
	syncer ClusterSyncer,
) WatchingController

NewClusterWatchingController periodically looks up all clusters and queues them cooldownDuration is how long to wait before allowing a new notification to fire the controller. Since our detection of change is coarse, we are being triggered every few second without new information. Until we get a changefeed, the cooldownDuration value is effectively the min resync time. This does NOT prevent us from re-executing on errors, so errors will continue to trigger fast checks as expected.

kubeApplierInformers is optional: when non-nil, the controller also enqueues on cluster-scoped ReadDesire and ApplyDesire events from the union kube-applier informer surface. The kube-applier writes per-desire status (including a Degraded condition) back onto these desires, so a desire update is how this controller learns "the kube-applier reported something new about a cluster" — the cluster Degraded aggregator folds cluster-scoped ApplyDesire/ReadDesire Degraded status into the cluster's Degraded condition. Only cluster-scoped desires are watched (node-pool-nested ones are ignored, see below). Delete desires are not wired in because their status does not carry cluster-state signal.

func NewExternalAuthWatchingController ¶

func NewExternalAuthWatchingController(
	name string,
	resourcesDBClient corecosmosstorage.ResourcesDBClient,
	informers coreinformers.BackendInformers,
	resyncDuration time.Duration,
	syncer ExternalAuthSyncer,
) WatchingController

NewExternalAuthWatchingController periodically looks up all ExternalAuths and queues them cooldownDuration is how long to wait before allowing a new notification to fire the controller. Since our detection of change is coarse, we are being triggered every few second without new information. Until we get a changefeed, the cooldownDuration value is effectively the min resync time. This does NOT prevent us from re-executing on errors, so errors will continue to trigger fast checks as expected.

func NewManagementClusterWatchingController ¶

func NewManagementClusterWatchingController(
	name string,
	fleetDBClient fleetcosmosstorage.FleetDBClient,
	fleetInformers fleetinformers.FleetInformers,
	resyncDuration time.Duration,
	syncer ManagementClusterSyncer,
) WatchingController

NewManagementClusterWatchingController periodically looks up all management clusters and queues them.

func NewNodePoolWatchingController ¶

func NewNodePoolWatchingController(
	name string,
	resourcesDBClient corecosmosstorage.ResourcesDBClient,
	informers coreinformers.BackendInformers,
	kubeApplierInformers *unionkubeapplierinformers.UnionKubeApplierInformers,
	resyncDuration time.Duration,
	syncer NodePoolSyncer,
) WatchingController

NewNodePoolWatchingController periodically looks up all NodePools and queues them cooldownDuration is how long to wait before allowing a new notification to fire the controller. Since our detection of change is coarse, we are being triggered every few second without new information. Until we get a changefeed, the cooldownDuration value is effectively the min resync time. This does NOT prevent us from re-executing on errors, so errors will continue to trigger fast checks as expected.

kubeApplierInformers is optional: when non-nil, the controller also enqueues on node-pool-scoped ReadDesire and ApplyDesire events from the union kube-applier informer surface. The kube-applier writes per-desire status (including a Degraded condition) back onto these desires, so a desire update is how this controller learns "the kube-applier reported something new about a node pool" — the node-pool Degraded aggregator folds node-pool-scoped ApplyDesire/ReadDesire Degraded status into the node pool's Degraded condition. Only node-pool-scoped desires are watched (cluster-scoped ones are ignored, see below). Delete desires are not wired in because their status does not carry node-pool-state signal.

func NewSubscriptionWatchingController ¶

func NewSubscriptionWatchingController(
	name string,
	informers coreinformers.BackendInformers,
	resyncDuration time.Duration,
	syncer SubscriptionSyncer,
) WatchingController

NewSubscriptionWatchingController periodically looks up all subscriptions and queues them. cooldownDuration is how long to wait before allowing a new notification to fire the controller. Since our detection of change is coarse, we are being triggered every few second without new information. Until we get a changefeed, the cooldownDuration value is effectively the min resync time. This does NOT prevent us from re-executing on errors, so errors will continue to trigger fast checks as expected.

func NewSystemAdminCredentialRequestWatchingController ¶

func NewSystemAdminCredentialRequestWatchingController(
	name string,
	resourcesDBClient corecosmosstorage.ResourcesDBClient,
	backendInformers coreinformers.BackendInformers,
	kubeApplierInformers *unionkubeapplierinformers.UnionKubeApplierInformers,
	resyncDuration time.Duration,
	syncer SystemAdminCredentialRequestSyncer,
) WatchingController

NewSystemAdminCredentialRequestWatchingController creates a controller that fires on individual SystemAdminCredentialRequest informer events rather than cluster-level events. This ensures controllers react immediately when a credential request is created or updated, instead of relying on periodic cluster resync.

kubeApplierInformers is optional: when non-nil, the controller also enqueues on ReadDesire and ApplyDesire events from the union kube-applier informer surface (the same pattern as ClusterWatchingController, but walking up to the credential request resource type instead of the cluster type).

func NewSystemAdminCredentialRevocationWatchingController ¶

func NewSystemAdminCredentialRevocationWatchingController(
	name string,
	resourcesDBClient corecosmosstorage.ResourcesDBClient,
	backendInformers coreinformers.BackendInformers,
	kubeApplierInformers *unionkubeapplierinformers.UnionKubeApplierInformers,
	resyncDuration time.Duration,
	syncer SystemAdminCredentialRevocationSyncer,
) WatchingController

NewSystemAdminCredentialRevocationWatchingController creates a controller that fires on individual SystemAdminCredentialRevocation informer events. Each revocation drives its own lifecycle (marking credential requests for deletion, managing the CRR desires, and final teardown), so keying on the revocation lets a small set of focused controllers react immediately to revocation changes and re-poll on resync.