use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use tatara_lisp::DeriveTataraDomain;
#[derive(DeriveTataraDomain, Clone, Debug, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "camelCase")]
#[tatara(keyword = "defrouting")]
pub struct RoutingSpec {
#[serde(default)]
pub hostnames: Vec<RoutingHostname>,
pub backend: RoutingBackend,
#[serde(default)]
pub stable_name_claim: bool,
#[serde(default)]
pub priority: i32,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct RoutingHostname {
pub app: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub instance: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cluster: Option<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct RoutingBackend {
pub service: String,
pub port: u16,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_issuer: Option<String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub ingress_annotations: BTreeMap<String, String>,
}
impl RoutingSpec {
pub fn has_hostnames(&self) -> bool {
!self.hostnames.is_empty()
}
pub fn emitted_fqdn_count(&self, claim_held: bool) -> usize {
self.hostnames.len() * if claim_held { 2 } else { 1 }
}
#[must_use]
pub const fn form(&self) -> RoutingForm {
RoutingForm::from_is_stable(self.stable_name_claim)
}
#[must_use]
pub fn has_form(&self, kind: RoutingForm) -> bool {
self.form() == kind
}
}
pub trait RoutingSpecOptionExt {
fn has_form(&self, kind: RoutingForm) -> bool;
}
impl RoutingSpecOptionExt for Option<RoutingSpec> {
fn has_form(&self, kind: RoutingForm) -> bool {
self.as_ref().is_some_and(|r| r.has_form(kind))
}
}
impl RoutingHostname {
pub fn is_named(&self) -> bool {
self.instance.as_deref().is_some_and(|s| !s.is_empty())
}
pub fn cluster_or<'a>(&'a self, fallback: &'a str) -> &'a str {
self.cluster.as_deref().unwrap_or(fallback)
}
#[must_use]
pub fn instanced(app: impl Into<String>, instance: impl Into<String>) -> Self {
Self {
app: app.into(),
instance: Some(instance.into()),
cluster: None,
}
}
#[must_use]
pub fn content_hashed(app: impl Into<String>) -> Self {
Self {
app: app.into(),
instance: None,
cluster: None,
}
}
}
impl RoutingBackend {
#[must_use]
pub fn plain(service: impl Into<String>, port: u16) -> Self {
Self {
service: service.into(),
port,
tls_issuer: None,
ingress_annotations: BTreeMap::new(),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, tatara_closed_set::DeriveClosedSet)]
#[closed_set(via = "as_str", display, generate_unknown)]
pub enum RoutingForm {
Stable,
Instance,
}
impl RoutingForm {
pub const ALL: [Self; 2] = [Self::Stable, Self::Instance];
pub const fn as_str(self) -> &'static str {
match self {
RoutingForm::Stable => "stable",
RoutingForm::Instance => "instance",
}
}
pub const fn from_is_stable(is_stable: bool) -> Self {
if is_stable {
RoutingForm::Stable
} else {
RoutingForm::Instance
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn demo_routing() -> RoutingSpec {
RoutingSpec {
hostnames: vec![
RoutingHostname::instanced("api", "demo-prod"),
RoutingHostname::instanced("gateway", "demo-prod"),
],
backend: RoutingBackend::plain("demo-app-gateway", 8000),
stable_name_claim: true,
priority: 100,
}
}
#[test]
fn empty_routing_resolves_no_hostnames() {
let r = RoutingSpec {
hostnames: vec![],
backend: RoutingBackend::plain("x", 80),
stable_name_claim: false,
priority: 0,
};
assert!(!r.has_hostnames());
assert_eq!(r.emitted_fqdn_count(false), 0);
assert_eq!(r.emitted_fqdn_count(true), 0);
}
#[test]
fn fqdn_count_doubles_when_claim_held() {
let r = demo_routing();
assert_eq!(r.emitted_fqdn_count(false), 2);
assert_eq!(r.emitted_fqdn_count(true), 4);
}
#[test]
fn hostname_is_named_when_instance_nonempty() {
let h = RoutingHostname::instanced("x", "env-a");
assert!(h.is_named());
let h_anon = RoutingHostname::content_hashed("x");
assert!(!h_anon.is_named());
let h_empty = RoutingHostname {
app: "x".into(),
instance: Some(String::new()),
cluster: None,
};
assert!(!h_empty.is_named()); }
#[test]
fn cluster_or_returns_slot_when_cluster_is_populated() {
let h = RoutingHostname {
app: "api".into(),
instance: None,
cluster: Some("pleme-prod".into()),
};
assert_eq!(h.cluster_or("pleme-dev"), "pleme-prod");
}
#[test]
fn cluster_or_falls_back_to_caller_string_when_cluster_is_none() {
let h = RoutingHostname::content_hashed("api");
assert_eq!(h.cluster_or("pleme-dev"), "pleme-dev");
}
#[test]
fn cluster_or_returns_empty_slice_when_cluster_is_explicitly_empty_string() {
let h = RoutingHostname {
app: "api".into(),
instance: None,
cluster: Some(String::new()),
};
assert_eq!(h.cluster_or("pleme-dev"), "");
}
#[test]
fn cluster_or_is_a_pure_projection() {
let h = RoutingHostname {
app: "api".into(),
instance: Some("demo-prod".into()),
cluster: Some("pleme-prod".into()),
};
let a = h.cluster_or("pleme-dev");
let b = h.cluster_or("pleme-dev");
assert_eq!(a, b);
assert_eq!(a, "pleme-prod");
}
#[test]
fn cluster_or_borrow_form_return_shape_matches_fmt_fqdn_arg_shape() {
use crate::hostname::fmt_fqdn;
let h = RoutingHostname::instanced("api", "demo-prod");
let host_cluster: &str = h.cluster_or("pleme-dev");
let fqdn = fmt_fqdn(
&h.app,
h.instance.as_deref().unwrap(),
host_cluster,
"use1",
"quero.lol",
)
.expect("fmt_fqdn");
assert_eq!(fqdn, "api.demo-prod.pleme-dev.use1.quero.lol");
}
#[test]
fn cluster_or_matches_pre_lift_chain_verbatim() {
let fallbacks = ["pleme-dev", "pleme-prod", "", "some-other-cluster"];
let cluster_slots = [
None,
Some(String::new()),
Some("pleme-prod".into()),
Some("edge-1".into()),
];
for fallback in fallbacks {
for cluster in &cluster_slots {
let h = RoutingHostname {
app: "api".into(),
instance: None,
cluster: cluster.clone(),
};
let pre_lift = h.cluster.as_deref().unwrap_or(fallback);
let via_primitive = h.cluster_or(fallback);
assert_eq!(
via_primitive, pre_lift,
"primitive must match pre-lift `.as_deref().unwrap_or(fallback)` chain \
byte-identically at (fallback={fallback:?}, cluster={cluster:?})"
);
}
}
}
#[test]
fn cluster_or_composes_with_stable_group_key_shape() {
let h = RoutingHostname::content_hashed("api");
let cluster = h.cluster_or("pleme-dev");
let key = format!("{cluster}/{}", h.app);
assert_eq!(key, "pleme-dev/api");
let h_over = RoutingHostname {
app: "api".into(),
instance: None,
cluster: Some("pleme-prod".into()),
};
let cluster = h_over.cluster_or("pleme-dev");
let key = format!("{cluster}/{}", h_over.app);
assert_eq!(key, "pleme-prod/api");
}
#[test]
fn cluster_or_lifetime_ties_output_to_the_shorter_of_self_or_fallback() {
let h = RoutingHostname::content_hashed("api");
{
let fallback = String::from("pleme-dev");
let slice = h.cluster_or(&fallback);
assert_eq!(slice, "pleme-dev");
}
}
#[test]
fn instanced_composes_populated_instance_with_default_cluster() {
let h = RoutingHostname::instanced("api", "demo-prod");
assert_eq!(h.app, "api");
assert_eq!(h.instance.as_deref(), Some("demo-prod"));
assert!(h.cluster.is_none());
}
#[test]
fn instanced_composes_byte_identical_to_pre_lift_literal_across_every_app_instance_pair() {
let pairs = [
("api", "demo-prod"),
("gateway", "demo-prod"),
("x", "env-a"),
];
for (app, instance) in pairs {
let via_primitive = RoutingHostname::instanced(app, instance);
let pre_lift = RoutingHostname {
app: app.into(),
instance: Some(instance.into()),
cluster: None,
};
assert_eq!(
via_primitive, pre_lift,
"primitive must match pre-lift `RoutingHostname {{ app, instance: Some(..), \
cluster: None }}` literal byte-identically at (app={app:?}, instance={instance:?})"
);
}
}
#[test]
fn instanced_is_named_via_peer_projection() {
assert!(RoutingHostname::instanced("api", "demo-prod").is_named());
}
#[test]
fn instanced_cluster_or_falls_back_to_caller_string() {
let h = RoutingHostname::instanced("api", "demo-prod");
assert_eq!(h.cluster_or("pleme-dev"), "pleme-dev");
}
#[test]
fn content_hashed_composes_unset_instance_with_default_cluster() {
let h = RoutingHostname::content_hashed("smoke");
assert_eq!(h.app, "smoke");
assert!(h.instance.is_none());
assert!(h.cluster.is_none());
}
#[test]
fn content_hashed_composes_byte_identical_to_pre_lift_literal_across_every_app_slot() {
let apps = ["api", "gateway", "smoke", "x"];
for app in apps {
let via_primitive = RoutingHostname::content_hashed(app);
let pre_lift = RoutingHostname {
app: app.into(),
instance: None,
cluster: None,
};
assert_eq!(
via_primitive, pre_lift,
"primitive must match pre-lift `RoutingHostname {{ app, instance: None, \
cluster: None }}` literal byte-identically at (app={app:?})"
);
}
}
#[test]
fn content_hashed_is_not_named() {
assert!(!RoutingHostname::content_hashed("smoke").is_named());
}
#[test]
fn plain_composes_default_issuer_and_empty_annotations() {
let b = RoutingBackend::plain("svc", 8080);
assert_eq!(b.service, "svc");
assert_eq!(b.port, 8080);
assert!(b.tls_issuer.is_none());
assert!(b.ingress_annotations.is_empty());
}
#[test]
fn plain_composes_byte_identical_to_pre_lift_literal_across_every_service_port_pair() {
let pairs = [
("demo-app-gateway", 8000_u16),
("svc", 80),
("svc", 8080),
("x", 80),
];
for (service, port) in pairs {
let via_primitive = RoutingBackend::plain(service, port);
let pre_lift = RoutingBackend {
service: service.into(),
port,
tls_issuer: None,
ingress_annotations: BTreeMap::new(),
};
assert_eq!(
via_primitive, pre_lift,
"primitive must match pre-lift `RoutingBackend {{ service, port, tls_issuer: \
None, ingress_annotations: BTreeMap::new() }}` literal byte-identically at \
(service={service:?}, port={port})"
);
}
}
#[test]
fn plain_wire_form_skips_defaulted_slots() {
let b = RoutingBackend::plain("svc", 80);
let yaml = serde_yaml::to_string(&b).unwrap();
assert!(!yaml.contains("tlsIssuer:"));
assert!(!yaml.contains("ingressAnnotations:"));
assert!(yaml.contains("service: svc"));
assert!(yaml.contains("port: 80"));
}
#[test]
fn serde_round_trip_via_yaml() {
let r = demo_routing();
let yaml = serde_yaml::to_string(&r).unwrap();
assert!(yaml.contains("hostnames:"));
assert!(yaml.contains("app: api"));
assert!(yaml.contains("instance: demo-prod"));
assert!(yaml.contains("backend:"));
assert!(yaml.contains("service: demo-app-gateway"));
assert!(yaml.contains("port: 8000"));
assert!(yaml.contains("stableNameClaim: true"));
assert!(yaml.contains("priority: 100"));
let back: RoutingSpec = serde_yaml::from_str(&yaml).unwrap();
assert_eq!(back.hostnames.len(), 2);
assert!(back.stable_name_claim);
assert_eq!(back.priority, 100);
}
#[test]
fn empty_fields_skip_serialize() {
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 8080),
stable_name_claim: false,
priority: 0,
};
let yaml = serde_yaml::to_string(&r).unwrap();
assert!(!yaml.contains("instance:"));
assert!(!yaml.contains("cluster:"));
assert!(!yaml.contains("tlsIssuer:"));
assert!(!yaml.contains("ingressAnnotations:"));
}
#[test]
fn lisp_round_trip_via_defrouting() {
let src = r#"
(defrouting demo-edges
:hostnames ((:app "api" :instance "demo-prod")
(:app "gateway" :instance "demo-prod"))
:backend (:service "demo-app-gateway"
:port 8000)
:stable-name-claim #t
:priority 100)
"#;
let defs: Vec<tatara_lisp::NamedDefinition<RoutingSpec>> =
tatara_lisp::compile_named::<RoutingSpec>(src).expect("compile");
assert_eq!(defs.len(), 1);
let d = &defs[0];
assert_eq!(d.name, "demo-edges");
assert_eq!(d.spec.hostnames.len(), 2);
assert_eq!(d.spec.hostnames[0].app, "api");
assert_eq!(d.spec.hostnames[0].instance.as_deref(), Some("demo-prod"));
assert_eq!(d.spec.backend.service, "demo-app-gateway");
assert_eq!(d.spec.backend.port, 8000);
assert!(d.spec.stable_name_claim);
assert_eq!(d.spec.priority, 100);
}
#[test]
fn lisp_round_trip_anonymous_instance() {
let src = r#"
(defrouting smoke-edges
:hostnames ((:app "smoke"))
:backend (:service "smoke" :port 80))
"#;
let defs: Vec<tatara_lisp::NamedDefinition<RoutingSpec>> =
tatara_lisp::compile_named::<RoutingSpec>(src).expect("compile");
let d = &defs[0];
assert_eq!(d.spec.hostnames.len(), 1);
assert_eq!(d.spec.hostnames[0].instance, None);
assert!(!d.spec.stable_name_claim); assert_eq!(d.spec.priority, 0); }
#[test]
fn routing_form_as_str_matches_wire_form_pre_lift() {
assert_eq!(RoutingForm::Stable.as_str(), "stable");
assert_eq!(RoutingForm::Instance.as_str(), "instance");
}
#[test]
fn routing_form_from_is_stable_routes_true_and_false() {
assert_eq!(RoutingForm::from_is_stable(true), RoutingForm::Stable);
assert_eq!(RoutingForm::from_is_stable(false), RoutingForm::Instance);
}
#[test]
fn routing_form_round_trip_via_bool() {
for is_stable in [true, false] {
let form = RoutingForm::from_is_stable(is_stable);
let expected = if is_stable { "stable" } else { "instance" };
assert_eq!(form.as_str(), expected);
}
}
#[test]
fn routing_form_is_well_formed_closed_set() {
tatara_closed_set::assert_closed_set_well_formed::<RoutingForm>();
}
#[test]
fn routing_form_display_matches_as_str() {
crate::tagged_union::assert_display_matches_label::<RoutingForm>();
}
#[test]
fn unknown_routing_form_errors() {
use std::str::FromStr;
for bad in ["Stable", "Instance", "STABLE", "instances", "Gateway"] {
let err = RoutingForm::from_str(bad).unwrap_err();
assert_eq!(err.0, bad, "error payload should echo input verbatim");
}
}
#[test]
fn routing_form_all_partitions_both_stable_name_claim_bool_arms() {
assert_eq!(RoutingForm::ALL.len(), 2);
for is_stable in [true, false] {
let form = RoutingForm::from_is_stable(is_stable);
assert!(
RoutingForm::ALL.contains(&form),
"from_is_stable({is_stable}) => {form:?} must be in RoutingForm::ALL",
);
}
assert_eq!(RoutingForm::from_is_stable(true), RoutingForm::Stable);
assert_eq!(RoutingForm::from_is_stable(false), RoutingForm::Instance);
}
#[test]
fn form_projects_stable_when_stable_name_claim_is_true() {
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: true,
priority: 0,
};
assert_eq!(r.form(), RoutingForm::Stable);
}
#[test]
fn form_projects_instance_when_stable_name_claim_is_false() {
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: false,
priority: 0,
};
assert_eq!(r.form(), RoutingForm::Instance);
}
#[test]
fn form_composes_through_the_one_from_is_stable_projection() {
for is_stable in [true, false] {
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: is_stable,
priority: 0,
};
assert_eq!(
r.form(),
RoutingForm::from_is_stable(is_stable),
"form() must delegate to from_is_stable({is_stable})",
);
}
}
#[test]
fn has_form_returns_true_on_diagonal_and_false_off_diagonal_across_all_kinds() {
for is_stable in [true, false] {
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: is_stable,
priority: 0,
};
let populated = RoutingForm::from_is_stable(is_stable);
for query in RoutingForm::ALL {
let expected = query == populated;
assert_eq!(
r.has_form(query),
expected,
"stable_name_claim={is_stable} populated={populated:?}: has_form({query:?}) drift",
);
}
}
}
#[test]
fn has_form_default_arm_is_instance() {
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: bool::default(),
priority: 0,
};
for kind in RoutingForm::ALL {
let expected = kind == RoutingForm::Instance;
assert_eq!(
r.has_form(kind),
expected,
"default (stable_name_claim=false) baseline: has_form({kind:?}) must be {expected}",
);
}
}
#[test]
fn has_form_coexists_with_has_hostnames() {
for is_stable in [true, false] {
let r_with_hostnames = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: is_stable,
priority: 0,
};
let r_empty = RoutingSpec {
hostnames: vec![],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: is_stable,
priority: 0,
};
let form = RoutingForm::from_is_stable(is_stable);
assert!(r_with_hostnames.has_hostnames());
assert!(!r_empty.has_hostnames());
assert!(r_with_hostnames.has_form(form));
assert!(r_empty.has_form(form));
}
}
#[test]
fn routing_spec_option_ext_has_form_returns_false_on_none_for_every_kind() {
let opt: Option<RoutingSpec> = None;
for kind in RoutingForm::ALL {
assert!(
!opt.has_form(kind),
"None carrier reported has_form({kind:?}) = true; \
the Option-carrier collapse arm must return false \
for every RoutingForm kind, including the derived \
default RoutingForm::Instance (an in-cluster-only \
Process declined the routing surface — it did NOT \
opt into Instance by omission)"
);
}
}
#[test]
fn routing_spec_option_ext_has_form_matches_inner_probe_when_present() {
for is_stable in [true, false] {
let inner = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend::plain("svc", 80),
stable_name_claim: is_stable,
priority: 0,
};
let opt: Option<RoutingSpec> = Some(inner.clone());
for probe in RoutingForm::ALL {
assert_eq!(
opt.has_form(probe),
inner.has_form(probe),
"Some-arm projection diverged from inner probe: \
is_stable={is_stable} probe={probe:?}"
);
}
}
}
#[test]
fn routing_form_annotation_key_is_prefixed_process_ns() {
assert_eq!(
crate::annotations::ROUTING_FORM,
"tatara.pleme.io/routing-form"
);
}
#[test]
fn routing_app_annotation_key_is_prefixed_process_ns() {
assert_eq!(crate::annotations::APP, "tatara.pleme.io/app");
}
#[test]
fn ingress_annotations_round_trip() {
let mut annotations = BTreeMap::new();
annotations.insert(
"nginx.ingress.kubernetes.io/rate-limit".into(),
"100".into(),
);
annotations.insert(
"nginx.ingress.kubernetes.io/proxy-body-size".into(),
"10m".into(),
);
let r = RoutingSpec {
hostnames: vec![RoutingHostname::content_hashed("api")],
backend: RoutingBackend {
service: "svc".into(),
port: 8080,
tls_issuer: Some("letsencrypt-prod".into()),
ingress_annotations: annotations,
},
stable_name_claim: false,
priority: 0,
};
let yaml = serde_yaml::to_string(&r).unwrap();
assert!(yaml.contains("tlsIssuer: letsencrypt-prod"));
assert!(yaml.contains("rate-limit"));
let back: RoutingSpec = serde_yaml::from_str(&yaml).unwrap();
assert_eq!(back.backend.tls_issuer.as_deref(), Some("letsencrypt-prod"));
assert_eq!(back.backend.ingress_annotations.len(), 2);
}
}