Struct mz_orchestrator_kubernetes::OrchestratorWorker

pub(crate) struct OrchestratorWorker {
    pub(crate) metrics_api: Api<PodMetrics>,
    pub(crate) custom_metrics_api: Api<MetricValueList>,
    pub(crate) service_api: Api<Service>,
    pub(crate) stateful_set_api: Api<StatefulSet>,
    pub(crate) pod_api: Api<Pod>,
    pub(crate) command_rx: UnboundedReceiver<WorkerCommand>,
}

A task executing blocking work for a NamespacedKubernetesOrchestrator in the background.

This type exists to enable making NamespacedKubernetesOrchestrator::ensure_service and NamespacedKubernetesOrchestrator::drop_service non-blocking, allowing invocation of these methods in latency-sensitive contexts.

Note that, apart from ensure_service and drop_service, this worker also handles blocking orchestrator calls that query service state (such as list_services). These need to be sequenced through the worker loop to ensure they linearize as expected. For example, we want to ensure that a list_services result contains exactly those services that were previously created with ensure_service and not yet dropped with drop_service.

Fields

metrics_api: Api<PodMetrics>

custom_metrics_api: Api<MetricValueList>

service_api: Api<Service>

stateful_set_api: Api<StatefulSet>

pod_api: Api<Pod>

command_rx: UnboundedReceiver<WorkerCommand>

Implementations

impl OrchestratorWorker

pub(crate) fn spawn(self, name: String) -> AbortOnDropHandle<()>

pub(crate) async fn run(self)

pub(crate) async fn handle_command(&mut self, cmd: WorkerCommand)

Handle a worker command.

If handling the command fails, it is automatically retried. All command handlers return K8sError, so we can reasonably assume that a failure is caused by issues communicating with the K8S server and that retrying resolves them eventually.

pub(crate) async fn fetch_service_metrics( &self, name: &str, info: &ServiceInfo, ) -> Vec<ServiceProcessMetrics>

pub(crate) async fn ensure_service( &self, desc: &ServiceDescription, ) -> Result<(), K8sError>

pub(crate) async fn drop_service(&self, name: &str) -> Result<(), K8sError>

pub(crate) async fn list_services( &self, namespace: &str, ) -> Result<Vec<String>, K8sError>