batata-client 0.0.2

Rust client for Batata/Nacos service discovery and configuration management
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137


use dashmap::DashMap;

use crate::api::naming::{Instance, Service};
use crate::common::build_service_key;

/// Service information cache
pub struct ServiceInfoCache {
    /// Cached services: key -> Service
    services: DashMap<String, Service>,
}

impl ServiceInfoCache {
    pub fn new() -> Self {
        Self {
            services: DashMap::new(),
        }
    }

    /// Get service from cache
    pub fn get(&self, namespace: &str, group_name: &str, service_name: &str) -> Option<Service> {
        let key = build_service_key(service_name, group_name, namespace);
        self.services.get(&key).map(|r| r.value().clone())
    }

    /// Put service into cache
    pub fn put(&self, namespace: &str, service: Service) {
        let key = build_service_key(&service.name, &service.group_name, namespace);
        self.services.insert(key, service);
    }

    /// Remove service from cache
    pub fn remove(
        &self,
        namespace: &str,
        group_name: &str,
        service_name: &str,
    ) -> Option<Service> {
        let key = build_service_key(service_name, group_name, namespace);
        self.services.remove(&key).map(|(_, v)| v)
    }

    /// Check if service exists in cache
    pub fn contains(&self, namespace: &str, group_name: &str, service_name: &str) -> bool {
        let key = build_service_key(service_name, group_name, namespace);
        self.services.contains_key(&key)
    }

    /// Get all healthy instances for a service
    pub fn get_healthy_instances(
        &self,
        namespace: &str,
        group_name: &str,
        service_name: &str,
    ) -> Vec<Instance> {
        self.get(namespace, group_name, service_name)
            .map(|s| s.hosts.into_iter().filter(|i| i.healthy && i.enabled).collect())
            .unwrap_or_default()
    }

    /// Get all instances for a service
    pub fn get_all_instances(
        &self,
        namespace: &str,
        group_name: &str,
        service_name: &str,
    ) -> Vec<Instance> {
        self.get(namespace, group_name, service_name)
            .map(|s| s.hosts)
            .unwrap_or_default()
    }

    /// Update service instances
    pub fn update_instances(
        &self,
        namespace: &str,
        group_name: &str,
        service_name: &str,
        instances: Vec<Instance>,
    ) {
        let key = build_service_key(service_name, group_name, namespace);
        if let Some(mut service) = self.services.get_mut(&key) {
            service.hosts = instances;
        } else {
            let mut service = Service::new(service_name, group_name);
            service.hosts = instances;
            self.services.insert(key, service);
        }
    }

    /// Get all cached service keys
    pub fn keys(&self) -> Vec<String> {
        self.services.iter().map(|r| r.key().clone()).collect()
    }

    /// Clear all cached services
    pub fn clear(&self) {
        self.services.clear();
    }

    /// Get cache size
    pub fn len(&self) -> usize {
        self.services.len()
    }

    /// Check if cache is empty
    pub fn is_empty(&self) -> bool {
        self.services.is_empty()
    }
}

impl Default for ServiceInfoCache {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_service_info_cache() {
        let cache = ServiceInfoCache::new();

        let mut service = Service::new("test-service", "DEFAULT_GROUP");
        service.hosts.push(Instance::new("127.0.0.1", 8080));

        cache.put("public", service);

        assert!(cache.contains("public", "DEFAULT_GROUP", "test-service"));

        let instances = cache.get_all_instances("public", "DEFAULT_GROUP", "test-service");
        assert_eq!(instances.len(), 1);
        assert_eq!(instances[0].ip, "127.0.0.1");
    }
}