Struct Controller 

pub struct Controller<Ctx>
where
    Ctx: Send + Sync + 'static + Context,
    Ctx::Error: Send + Sync + 'static,
    for<'de> Ctx::Resource: Send + Sync + 'static + Clone + Debug + Serialize + Deserialize<'de>,
    <Ctx::Resource as Resource>::DynamicType: Eq + Clone + Hash + Default + Debug + Unpin,
{ /* private fields */ }

The Controller watches a set of resources, calling methods on the provided Context when events occur.

Implementations

impl<Ctx> Controller<Ctx>

where Ctx: Send + Sync + 'static + Context, Ctx::Error: Send + Sync + 'static, for<'de> Ctx::Resource: Clone + Debug + Serialize + Deserialize<'de>, <Ctx::Resource as Resource>::DynamicType: Eq + Clone + Hash + Default + Debug + Unpin,

pub fn namespaced( client: Client, context: Ctx, namespace: &str, wc: Config, ) -> Self

where Ctx::Resource: Resource<Scope = NamespaceResourceScope>,

Creates a new controller for a namespaced resource using the given client. The context given determines the type of resource to watch (via the Context::Resource type provided as part of the trait implementation). The resources to be watched will be limited to resources in the given namespace. A watcher::Config can be given to limit the resources watched (for instance, watcher::Config::default().labels("app=myapp")).

pub fn namespaced_all(client: Client, context: Ctx, wc: Config) -> Self

where Ctx::Resource: Resource<Scope = NamespaceResourceScope>,

Creates a new controller for a namespaced resource using the given client. The context given determines the type of resource to watch (via the Context::Resource type provided as part of the trait implementation). The resources to be watched will not be limited by namespace. A watcher::Config can be given to limit the resources watched (for instance, watcher::Config::default().labels("app=myapp")).

pub fn cluster(client: Client, context: Ctx, wc: Config) -> Self

where Ctx::Resource: Resource<Scope = ClusterResourceScope>,

Creates a new controller for a cluster-scoped resource using the given client. The context given determines the type of resource to watch (via the Context::Resource type provided as part of the trait implementation). A watcher::Config can be given to limit the resources watched (for instance, watcher::Config::default().labels("app=myapp")).

pub fn with_name(self, name: impl Into<String>) -> Self

Sets the name identifying this controller in its metrics (the controller field of ReconcileRecord and StepRecord), and in the controller field of its reconcile tracing span. Defaults to Context::FINALIZER_NAME if set, and otherwise to the kind of the resource being watched.

Controllers sharing an observer must have distinct names, or their metrics will be merged.

pub fn with_observer(self, observer: Arc<dyn ReconcileObserver>) -> Self

Reports every reconciliation pass, and every step within one, to observer. See the observe module.

pub fn with_event_recorder(self, events: Arc<EventRecorder>) -> Self

Publishes a Kubernetes event on the resource whenever reconciling it fails, as determined by Context::failure_event, and enables TraceMetadata::publish_event for the context’s own events. See the events module, including for the RBAC permissions this requires.

events must not be given to any other controller. Besides every event appearing to come from the same controller, a successful pass of one controller would reset the aggregation of another’s failure events for the same resource.

pub async fn run(self)

Run the controller. This method will not return. The Context given to the constructor will have its apply method called when a resource is created or updated, and its cleanup method called when a resource is about to be deleted.

To run multiple replicas of a controller with only one reconciling at a time, pass this method’s future to LeaderElection::with_lease.

pub fn with_controller<F>(self, f: F) -> Self

where F: FnOnce(Controller<Ctx::Resource>) -> Controller<Ctx::Resource>,

Allow configuring the underlying kube_runtime::Controller. For example, you can use controller.with_controller(|controller| controller.with_config(Config::default().concurrency(10))) to limit the created controller to reconciling 10 resources at once.