use crate::config::{Config, SwarmSecurity, SwarmTransport};
use crate::error::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SwarmStack {
pub security: SwarmSecurity,
pub transport: SwarmTransport,
}
impl SwarmStack {
pub fn from_config(cfg: &Config) -> Self {
Self {
security: cfg.swarm_security,
transport: cfg.swarm_transport,
}
}
pub fn is_implemented(self) -> bool {
match (self.security, self.transport) {
(SwarmSecurity::Mtls, SwarmTransport::Tcp) => true,
(SwarmSecurity::Mse, SwarmTransport::Tcp) => true,
(SwarmSecurity::Mse, SwarmTransport::Utp) => crate::utp::IMPLEMENTED,
(SwarmSecurity::Mtls, SwarmTransport::Utp) => false,
}
}
pub fn describe(self) -> String {
format!("{}+{}", self.security.as_str(), self.transport.as_str())
}
pub fn backend(self) -> SwarmBackend {
match (self.security, self.transport) {
(SwarmSecurity::Mtls, SwarmTransport::Tcp) => SwarmBackend::MtlsTcp,
(SwarmSecurity::Mse, SwarmTransport::Tcp) => SwarmBackend::MseTcp,
(SwarmSecurity::Mse, SwarmTransport::Utp) => SwarmBackend::MseUtp,
(SwarmSecurity::Mtls, SwarmTransport::Utp) => SwarmBackend::Invalid,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SwarmBackend {
MtlsTcp,
MseTcp,
MseUtp,
Invalid,
}
pub fn validate_swarm_stack(cfg: &Config) -> Result<()> {
let stack = SwarmStack::from_config(cfg);
if matches!(
(stack.security, stack.transport),
(SwarmSecurity::Mtls, SwarmTransport::Utp)
) {
return Err(Error::Config(
"swarm-security \"mtls\" requires swarm-transport \"tcp\" (TLS is TCP-only; use mse+utp)"
.into(),
));
}
if stack.is_implemented() {
return Ok(());
}
Err(Error::Config(format!(
"swarm stack {} is not implemented",
stack.describe()
)))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_stack_is_mtls_tcp() {
let cfg = Config::default();
let stack = SwarmStack::from_config(&cfg);
assert_eq!(stack.backend(), SwarmBackend::MtlsTcp);
validate_swarm_stack(&cfg).expect("default ok");
}
#[test]
fn mse_tcp_is_allowed() {
let cfg = Config::default().with_swarm_security(SwarmSecurity::Mse);
assert_eq!(SwarmStack::from_config(&cfg).backend(), SwarmBackend::MseTcp);
validate_swarm_stack(&cfg).expect("mse+tcp");
}
#[test]
fn mse_utp_is_allowed() {
let cfg = Config::default()
.with_swarm_security(SwarmSecurity::Mse)
.with_swarm_transport(SwarmTransport::Utp);
assert_eq!(SwarmStack::from_config(&cfg).backend(), SwarmBackend::MseUtp);
validate_swarm_stack(&cfg).expect("mse+utp");
}
#[test]
fn mtls_utp_rejected() {
let cfg = Config::default().with_swarm_transport(SwarmTransport::Utp);
let err = validate_swarm_stack(&cfg).expect_err("mtls+utp");
assert!(err.to_string().contains("TCP-only") || err.to_string().contains("mtls"));
}
}