Struct mz_orchestrator_process::OrchestratorWorker

pub(crate) struct OrchestratorWorker {
    pub(crate) config: Arc<NamespacedProcessOrchestratorConfig>,
    pub(crate) services: Arc<Mutex<BTreeMap<String, Vec<ProcessState>>>>,
    pub(crate) service_event_tx: Sender<ServiceEvent>,
    pub(crate) system: System,
    pub(crate) command_rx: UnboundedReceiver<WorkerCommand>,
}

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

This type exists to enable making NamespacedProcessOrchestrator::ensure_service and NamespacedProcessOrchestrator::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

config: Arc<NamespacedProcessOrchestratorConfig>

services: Arc<Mutex<BTreeMap<String, Vec<ProcessState>>>>

service_event_tx: Sender<ServiceEvent>

system: System

command_rx: UnboundedReceiver<WorkerCommand>

Implementations

impl OrchestratorWorker

pub(crate) fn spawn(self) -> AbortOnDropHandle<()>

pub(crate) async fn run(self)

pub(crate) fn fetch_service_metrics( &mut self, id: &str, ) -> Result<Vec<ServiceProcessMetrics>, Error>

pub(crate) async fn ensure_service( &self, id: String, __arg2: ServiceConfig, ) -> Result<(), Error>

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

pub(crate) async fn list_services(&self) -> Result<Vec<String>, Error>

pub(crate) fn supervise_service_process( &self, _: ServiceProcessConfig<'_>, ) -> impl Future<Output = ()>

pub(crate) async fn maybe_write_prometheus_service_discovery_file(&self)