camel-core 0.18.0

Core engine for rust-camel
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//! ControllerComponentContext — a thin [`ComponentContext`] implementation used
//! inside [`DefaultRouteController`](super::route_controller::DefaultRouteController)
//! for endpoint resolution and observability during route compilation and startup.

use std::sync::Arc;

use camel_api::metrics::MetricsCollector;
use camel_api::{AsyncHealthCheck, PlatformService};
use camel_component_api::ComponentContext;
use camel_processor::aggregator::SharedLanguageRegistry;

use crate::health_registry::HealthCheckRegistry;
use crate::shared::components::domain::Registry;

/// A [`ComponentContext`] that delegates to the controller's registries.
pub(crate) struct ControllerComponentContext {
    registry: Arc<std::sync::Mutex<Registry>>,
    languages: SharedLanguageRegistry,
    metrics: Arc<dyn MetricsCollector>,
    platform_service: Arc<dyn PlatformService>,
    health_registry: Arc<HealthCheckRegistry>,
    route_id: Option<String>,
}

impl ControllerComponentContext {
    pub(crate) fn new(
        registry: Arc<std::sync::Mutex<Registry>>,
        languages: SharedLanguageRegistry,
        metrics: Arc<dyn MetricsCollector>,
        platform_service: Arc<dyn PlatformService>,
        health_registry: Arc<HealthCheckRegistry>,
        route_id: Option<String>,
    ) -> Self {
        Self {
            registry,
            languages,
            metrics,
            platform_service,
            health_registry,
            route_id,
        }
    }
}

impl ComponentContext for ControllerComponentContext {
    fn resolve_component(&self, scheme: &str) -> Option<Arc<dyn camel_component_api::Component>> {
        self.registry.lock().ok()?.get(scheme)
    }

    fn resolve_language(&self, name: &str) -> Option<Arc<dyn camel_language_api::Language>> {
        self.languages.lock().ok()?.get(name).cloned()
    }

    fn metrics(&self) -> Arc<dyn MetricsCollector> {
        Arc::clone(&self.metrics)
    }

    fn platform_service(&self) -> Arc<dyn PlatformService> {
        Arc::clone(&self.platform_service)
    }

    fn register_route_health_check(&self, route_id: &str, check: Arc<dyn AsyncHealthCheck>) {
        self.health_registry.register_for_route(route_id, check);
    }

    fn unregister_route_health_check(&self, route_id: &str) {
        self.health_registry.unregister_for_route(route_id);
    }

    fn route_id(&self) -> Option<&str> {
        self.route_id.as_deref()
    }
}