tatara-core 0.2.97

Shared domain types, config, and cluster types for tatara
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

//! Service catalog types for tatara's consul-like service registry.
//!
//! Services are automatically registered when allocations start and
//! deregistered when they stop or become unhealthy. The catalog is
//! replicated via Raft for consistency and propagated via gossip for
//! fast local lookups.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Health status of a service instance.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ServiceHealth {
    Passing,
    Warning,
    Critical,
    Maintenance,
}

impl Default for ServiceHealth {
    fn default() -> Self {
        Self::Passing
    }
}

/// A registered service instance in the catalog.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceEntry {
    /// Human-readable service name (e.g., "hanabi", "lilitu-backend").
    pub service_name: String,

    /// Unique instance ID (e.g., "hanabi-i-{alloc_id}").
    pub service_id: String,

    /// Node hosting this instance.
    pub node_id: String,

    /// IP address or hostname.
    pub address: String,

    /// Port number.
    pub port: u16,

    /// Optional tags for filtering (e.g., ["production", "v2.1"]).
    #[serde(default)]
    pub tags: Vec<String>,

    /// Arbitrary metadata.
    #[serde(default)]
    pub meta: HashMap<String, String>,

    /// Current health status.
    #[serde(default)]
    pub health: ServiceHealth,

    /// When this instance was registered.
    pub registered_at: DateTime<Utc>,

    /// Allocation ID that owns this service instance.
    pub alloc_id: Option<String>,
}

/// Query parameters for catalog lookups.
#[derive(Debug, Clone, Default)]
pub struct ServiceQuery {
    /// Service name to look up.
    pub service: String,

    /// Optional tag filter.
    pub tag: Option<String>,

    /// Only return healthy instances.
    pub healthy_only: bool,

    /// Prefer instances near this node.
    pub near: Option<String>,
}

impl ServiceEntry {
    /// Check if this entry matches a query.
    pub fn matches(&self, query: &ServiceQuery) -> bool {
        if self.service_name != query.service {
            return false;
        }
        if let Some(tag) = &query.tag {
            if !self.tags.contains(tag) {
                return false;
            }
        }
        if query.healthy_only && self.health != ServiceHealth::Passing {
            return false;
        }
        true
    }
}