Struct RegistryComponentContext 

pub struct RegistryComponentContext { /* private fields */ }

Adapter that lets Registry participate as a ComponentContext.

Wraps the shared Arc<Mutex<Registry>> and delegates resolve_component to Registry::get. The metrics collector is threaded in from the composition root (camel-cli) at construction; it is the ADR-0066 late-bound handle, not a backend snapshot, so late registrations flow through camel_component_api::ComponentContext::metrics without re-snapshotting. The components-lever snapshot gates only the component-operations family — the error family is never lever-gated. When no collector is wired (e.g. compile-time security scan, standalone examples without a live context), construction resolves camel_api::NoOpMetrics.

The registry reference is non-owning: the context holds only a std::sync::Weak to the registry, so it never keeps the registry (and, transitively, the CamelContext that owns it) alive. Component resolution works only while a strong registry reference exists elsewhere — the owning CamelContext, or an anchor the embedder retains. Once the last strong reference drops, resolution returns None.

Shutdown binding is optional: new leaves the context unbound (compile-time scans, tests), while with_shutdown_slot binds it to the owning context’s shutdown-token slot so resolved producers observe Runtime shutdown.

Implementations

impl RegistryComponentContext

pub fn new( registry: Arc<Mutex<Registry>>, metrics: Option<Arc<dyn MetricsCollector>>, components_enabled: bool, ) -> Self

Builds the context, resolving the collector once: metrics when wired, NoOpMetrics otherwise.

pub fn with_shutdown_slot(self, slot: Arc<Mutex<CancellationToken>>) -> Self

Binds this context to a shutdown-token slot that mirrors the owning CamelContext’s CURRENT shutdown token.

The slot is written at context build time and re-written by every start(), so shutdown_token resolves the token per call: after a stop/start cycle the resolved token is the new boot’s token, never a stale cancelled one. The Arc shares only the slot — it does NOT extend the context’s lifetime, mirroring this struct’s Weak-registry ownership: once the owning context drops, its token is never cancelled (the same observable outcome as resolve_component returning None).

Trait Implementations

impl ComponentContext for RegistryComponentContext

fn shutdown_token(&self) -> Option<CancellationToken>

The owning context’s CURRENT shutdown token, read through the slot mirror at call time (see with_shutdown_slot). Poison-tolerant: a poisoned slot resolves None rather than panicking, degrading to the slot-less default (callers mint an uncancelled local root — fail-safe, never fail-boot).

fn resolve_component(&self, scheme: &str) -> Option<Arc<dyn Component>>

Resolve a component by scheme.

fn resolve_language(&self, _name: &str) -> Option<Arc<dyn Language>>

Resolve a language by name.

fn metrics(&self) -> Arc<dyn MetricsCollector>

Access the active metrics collector.

fn component_metrics_enabled(&self) -> bool

Snapshot of the [observability.metrics].components lever — gates only the uniform component-operations family served through RuntimeObservability::component_metrics(); error-family emission is never lever-gated. Default false (opt-in); CamelContext overrides this with its MetricsLeversConfig snapshot.

fn platform_service(&self) -> Arc<dyn PlatformService>

Access the active platform service.

fn register_route_health_check( &self, _route_id: &str, _check: Arc<dyn AsyncHealthCheck>, )

fn unregister_route_health_check(&self, _route_id: &str)

fn in_flight_counter(&self) -> Option<Arc<InFlightGauge>>

Context-global gauge of accepted-not-completed exchanges (drainclaim). Production contexts return the gauge installed on every ConsumerContext at consumer start and read by CamelContext::total_in_flight() for the drain verdict. Default None keeps test contexts uncounted.

fn health(&self) -> Arc<dyn HealthCheckRegistry>

Access the active health-check registry.

fn route_id(&self) -> Option<&str>

fn register_current_route_health_check(&self, check: Arc<dyn AsyncHealthCheck>)