Struct CamelContext 

pub struct CamelContext { /* private fields */ }

The CamelContext is the runtime engine that manages components, routes, and their lifecycle.

Lifecycle

A CamelContext is single-use: call start() once to launch routes, then stop() or abort() to shut down. Restarting a stopped context is not supported — create a new instance instead.

Implementations

impl CamelContext

pub fn builder() -> CamelContextBuilder

pub async fn set_error_handler(&mut self, config: ErrorHandlerConfig)

Set a global error handler applied to all routes without a per-route handler.

pub async fn set_tracing(&mut self, enabled: bool)

Enable or disable tracing globally.

pub async fn set_tracer_config(&mut self, config: TracerConfig)

Configure tracing with full config.

pub async fn with_tracing(self) -> Self

Builder-style: enable tracing with default config.

pub async fn with_tracer_config(self, config: TracerConfig) -> Self

Builder-style: configure tracing with custom config. Note: tracing subscriber initialization (stdout/file output) is handled separately via init_tracing_subscriber (called in camel-config bridge).

pub fn with_lifecycle<L: Lifecycle + 'static>(self, service: L) -> Self

Register a lifecycle service (Apache Camel: addService pattern)

For services exposing as_function_invoker(), the invoker is propagated to the route controller so that subsequent route definitions with function steps work correctly.

Prefer CamelContextBuilder::with_lifecycle when possible, which wires the invoker at build time before any routes are added.

pub fn register_component<C: Component + 'static>(&mut self, component: C)

Register a component with this context.

pub fn add_startup_check(&mut self, check: Box<dyn ConfigCheck>)

Register a startup ConfigCheck to be evaluated at the head of start(). Established by ADR-0033.

Checks are drained and executed synchronously before any route consumer is started. If any check returns Err, start() fails closed with CamelError::Config(_) and no route is started. The check list is consumed (moved) during start() so this method may be called multiple times to register an arbitrary number of checks.

pub fn register_language( &mut self, name: impl Into<String>, lang: Box<dyn Language>, ) -> Result<(), LanguageRegistryError>

Register a language with this context, keyed by name.

Returns Err(LanguageRegistryError::AlreadyRegistered) if a language with the same name is already registered. Use resolve_language to check before registering, or choose a distinct name.

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

Resolve a language by name. Returns None if not registered.

pub async fn add_route_definition( &self, definition: RouteDefinition, ) -> Result<(), CamelError>

Add a route definition to this context.

The route must have an ID. Steps are resolved immediately using registered components.

pub fn registry(&self) -> MutexGuard<'_, Registry>

Access the component registry.

pub fn registry_arc(&self) -> Arc<Mutex<Registry>>

Access the shared component registry Arc.

pub fn runtime_execution_handle(&self) -> RuntimeExecutionHandle

Get runtime execution handle for file-watcher integrations.

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

Get the metrics collector.

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

Get the platform service.

pub fn readiness_gate(&self) -> Arc<dyn ReadinessGate>

Get the readiness gate port.

pub fn platform_identity(&self) -> PlatformIdentity

Get the platform identity.

pub fn leadership(&self) -> Arc<dyn LeadershipService>

Get the leadership service port.

pub fn runtime(&self) -> Arc<dyn RuntimeHandle>

Get runtime command/query bus handle.

pub fn producer_context(&self) -> ProducerContext

Build a producer context wired to this runtime.

pub async fn runtime_route_status( &self, route_id: &str, ) -> Result<Option<String>, CamelError>

Query route status via runtime read-model.

pub async fn start(&mut self) -> Result<(), CamelError>

Start all routes. Each route’s consumer will begin producing exchanges.

Only routes with auto_startup == true will be started, in order of their startup_order (lower values start first).

pub async fn stop(&mut self) -> Result<(), CamelError>

Graceful shutdown with default 30-second timeout.

pub async fn stop_timeout( &mut self, _timeout: Duration, ) -> Result<(), CamelError>

Graceful shutdown with custom timeout.

Note: The timeout parameter is currently not propagated to the RouteController’s per-route shutdown timeout. The RouteController uses a hardcoded 5-second default (DEFAULT_SHUTDOWN_TIMEOUT). Full propagation is planned for a future version.

pub fn shutdown_timeout(&self) -> Duration

Get the graceful shutdown timeout used by stop().

pub fn set_shutdown_timeout(&mut self, timeout: Duration)

Set the graceful shutdown timeout used by stop().

pub async fn abort(&mut self)

Immediate abort — kills all tasks without draining.

pub async fn health_check(&self) -> HealthReport

Check health status of all registered services and lifecycle services.

pub fn health_registry(&self) -> Arc<HealthCheckRegistry>

pub fn set_component_config<T: 'static + Send + Sync>(&mut self, config: T)

Store a component config. Overwrites any previously stored config of the same type.

pub fn get_component_config<T: 'static + Send + Sync>(&self) -> Option<&T>

Retrieve a stored component config by type. Returns None if not stored.

pub fn add_route_template( &self, spec: RouteTemplateSpec, ) -> Result<(), CamelError>

Register a route template specification.

Returns Err(CamelError) if a template with the same ID is already registered.

pub fn get_route_template(&self, id: &str) -> Option<RouteTemplateSpec>

Retrieve a route template specification by its ID.

pub fn template_ids(&self) -> Vec<String>

Return all registered template IDs.

pub fn record_template_instance(&self, record: TemplateInstanceRecord)

Record a newly instantiated template instance.

pub fn template_instances( &self, template_id: &str, ) -> Vec<TemplateInstanceRecord>

Return all instance records for a given template ID.

pub fn register_idempotent_repository( &mut self, name: impl Into<String>, repo: Arc<dyn IdempotentRepository>, ) -> Result<(), RegistryError>

Register an idempotent repository.

Returns Err(RegistryError::AlreadyRegistered) if a repository with the same name is already registered.

pub fn idempotent_repository( &self, name: &str, ) -> Option<Arc<dyn IdempotentRepository>>

Retrieve an idempotent repository by name.

pub fn register_claim_check_repository( &mut self, name: impl Into<String>, repo: Arc<dyn ClaimCheckRepository>, ) -> Result<(), RegistryError>

Register a claim check repository.

Returns Err(RegistryError::AlreadyRegistered) if a repository with the same name is already registered.

pub fn claim_check_repository( &self, name: &str, ) -> Option<Arc<dyn ClaimCheckRepository>>

Retrieve a claim check repository by name.

Trait Implementations

impl ComponentContext for CamelContext

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 health(&self) -> Arc<dyn HealthCheckRegistry>

Access the active health-check registry.

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 route_id(&self) -> Option<&str>

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

impl ComponentRegistrar for CamelContext

fn register_component_dyn(&mut self, component: Arc<dyn Component>)

Register a component instance.

impl HealthSource for CamelContext

fn liveness<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HealthStatus> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn readiness<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HealthStatus> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn health_report<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HealthReport> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn startup<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HealthStatus> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Default: Healthy — non-K8s implementors need not override.