use async_trait::async_trait;
use http::HeaderMap;
use std::collections::HashMap;
use crate::error::{GarrisonError, GarrisonResult};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TenantSource {
Header,
Subdomain,
Claim,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TenantContext {
pub tenant_id: i64,
pub resolved_from: TenantSource,
}
#[allow(missing_docs)]
mod tenant_local {
use super::TenantContext;
tokio::task_local! {
pub static TENANT: TenantContext;
}
}
pub use tenant_local::TENANT;
pub fn current_tenant_id_strict() -> Option<i64> {
TENANT.try_get().ok().map(|ctx| ctx.tenant_id)
}
pub fn current_tenant_id_or_error() -> GarrisonResult<i64> {
current_tenant_id_strict()
.ok_or_else(|| GarrisonError::Config("ctx-tenant-context-missing::".into()))
}
pub const SESSION_TENANT_ATTR_KEY: &str = "__garrison_tenant_id";
#[async_trait]
pub trait TenantResolver: Send + Sync {
async fn resolve(&self, headers: &HeaderMap) -> GarrisonResult<TenantContext>;
}
#[derive(Debug, Clone, Default)]
pub struct HeaderTenantResolver;
#[async_trait]
impl TenantResolver for HeaderTenantResolver {
async fn resolve(&self, headers: &HeaderMap) -> GarrisonResult<TenantContext> {
let value = headers
.get("X-Tenant-Id")
.ok_or_else(|| GarrisonError::Config("ctx-tenant-id-missing::".into()))?;
let raw = value
.to_str()
.map_err(|e| GarrisonError::Config(format!("ctx-tenant-id-not-ascii::{e}")))?;
let tenant_id = raw
.parse::<i64>()
.map_err(|e| GarrisonError::Config(format!("ctx-tenant-id-invalid::`{raw}`: {e}")))?;
Ok(TenantContext {
tenant_id,
resolved_from: TenantSource::Header,
})
}
}
#[derive(Debug, Clone, Default)]
pub struct SubdomainTenantResolver {
pub mapping: HashMap<String, i64>,
}
#[async_trait]
impl TenantResolver for SubdomainTenantResolver {
async fn resolve(&self, headers: &HeaderMap) -> GarrisonResult<TenantContext> {
let host = headers
.get("Host")
.ok_or_else(|| GarrisonError::Config("ctx-host-missing::".into()))?
.to_str()
.map_err(|e| GarrisonError::Config(format!("ctx-host-not-ascii::{e}")))?;
let hostname = if host.starts_with('[') {
host.split_once(']')
.map(|(inner, _)| inner)
.filter(|s| !s.is_empty())
.unwrap_or(host)
} else {
host.split(':').next().unwrap_or(host)
};
let subdomain = hostname.split('.').next().unwrap_or(hostname);
if subdomain.is_empty() {
return Err(GarrisonError::Config(format!(
"ctx-host-empty-subdomain::{host}"
)));
}
let tenant_id = *self.mapping.get(subdomain).ok_or_else(|| {
GarrisonError::Config(format!("ctx-host-unknown-subdomain::{subdomain}"))
})?;
Ok(TenantContext {
tenant_id,
resolved_from: TenantSource::Subdomain,
})
}
}
#[cfg(feature = "protocol-jwt")]
#[derive(Clone)]
pub struct ClaimTenantResolver {
pub jwt_secret: String,
pub expected_issuers: Vec<String>,
pub expected_audiences: Vec<String>,
}
#[cfg(feature = "protocol-jwt")]
impl std::fmt::Debug for ClaimTenantResolver {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ClaimTenantResolver")
.field("jwt_secret", &"<redacted>")
.field("expected_issuers", &self.expected_issuers)
.field("expected_audiences", &self.expected_audiences)
.finish()
}
}
#[cfg(feature = "protocol-jwt")]
impl ClaimTenantResolver {
pub fn new(jwt_secret: String) -> Self {
Self {
jwt_secret,
expected_issuers: Vec::new(),
expected_audiences: Vec::new(),
}
}
pub fn with_expected_issuers(mut self, issuers: Vec<String>) -> Self {
self.expected_issuers = issuers;
self
}
pub fn with_expected_audiences(mut self, audiences: Vec<String>) -> Self {
self.expected_audiences = audiences;
self
}
}
#[cfg(feature = "protocol-jwt")]
#[derive(serde::Deserialize)]
struct TenantClaims {
tenant_id: i64,
}
#[cfg(feature = "protocol-jwt")]
#[async_trait]
impl TenantResolver for ClaimTenantResolver {
async fn resolve(&self, headers: &HeaderMap) -> GarrisonResult<TenantContext> {
use jsonwebtoken::{decode, Algorithm, DecodingKey, Validation};
let auth = headers
.get("Authorization")
.ok_or_else(|| GarrisonError::InvalidToken("ctx-auth-header-missing::".into()))?
.to_str()
.map_err(|e| GarrisonError::InvalidToken(format!("ctx-auth-not-ascii::{e}")))?;
let mut parts = auth.splitn(2, ' ');
let scheme = parts
.next()
.ok_or_else(|| GarrisonError::InvalidToken("ctx-auth-header-empty::".into()))?;
let jwt = parts
.next()
.ok_or_else(|| GarrisonError::InvalidToken("ctx-auth-token-missing::".into()))?;
if !scheme.eq_ignore_ascii_case("Bearer") {
return Err(GarrisonError::InvalidToken(format!(
"ctx-auth-scheme-unsupported::`{scheme}`"
)));
}
let key = DecodingKey::from_secret(self.jwt_secret.as_bytes());
let mut validation = Validation::new(Algorithm::HS256);
validation.validate_exp = true;
validation.leeway = 0;
if !self.expected_issuers.is_empty() {
validation.set_issuer(&self.expected_issuers);
}
if !self.expected_audiences.is_empty() {
validation.set_audience(&self.expected_audiences);
}
let data = decode::<TenantClaims>(jwt, &key, &validation).map_err(|e| {
GarrisonError::InvalidToken(format!("ctx-tenant-jwt-verify-failed::{e}"))
})?;
Ok(TenantContext {
tenant_id: data.claims.tenant_id,
resolved_from: TenantSource::Claim,
})
}
}
#[cfg(any(test, feature = "testing"))]
pub async fn with_default_tenant<F, R>(f: F) -> R
where
F: std::future::Future<Output = R>,
{
let ctx = TenantContext {
tenant_id: 0,
resolved_from: TenantSource::Header,
};
TENANT.scope(ctx, f).await
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tenant_context_constructs_with_tenant_id_and_source() {
let ctx = TenantContext {
tenant_id: 42,
resolved_from: TenantSource::Header,
};
assert_eq!(ctx.tenant_id, 42);
assert!(matches!(ctx.resolved_from, TenantSource::Header));
}
#[tokio::test]
async fn header_tenant_resolver_extracts_x_tenant_id() {
let mut headers = http::HeaderMap::new();
headers.insert("X-Tenant-Id", "42".parse().expect("valid header value"));
let ctx = HeaderTenantResolver
.resolve(&headers)
.await
.expect("X-Tenant-Id 存在时应解析成功");
assert_eq!(ctx.tenant_id, 42);
assert!(matches!(ctx.resolved_from, TenantSource::Header));
}
#[tokio::test]
async fn header_tenant_resolver_returns_config_error_when_header_missing() {
let headers = http::HeaderMap::new();
let result = HeaderTenantResolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::Config(_))));
}
#[tokio::test]
async fn header_tenant_resolver_returns_config_error_when_header_not_i64() {
let mut headers = http::HeaderMap::new();
headers.insert("X-Tenant-Id", "not-a-number".parse().unwrap());
let result = HeaderTenantResolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::Config(_))));
}
#[tokio::test]
async fn tenant_scope_enter_returns_context_value() {
let ctx = TenantContext {
tenant_id: 42,
resolved_from: TenantSource::Header,
};
let tenant_id = TENANT.scope(ctx, async { TENANT.get().tenant_id }).await;
assert_eq!(tenant_id, 42);
}
#[tokio::test]
async fn tenant_try_get_returns_err_when_no_scope() {
assert!(TENANT.try_get().is_err());
}
#[tokio::test]
async fn strict_returns_none_without_scope() {
assert_eq!(current_tenant_id_strict(), None);
}
#[tokio::test]
async fn strict_returns_some_with_scope() {
let ctx = TenantContext {
tenant_id: 42,
resolved_from: TenantSource::Header,
};
let result = TENANT
.scope(ctx, async { current_tenant_id_strict() })
.await;
assert_eq!(result, Some(42));
}
#[tokio::test]
async fn or_error_returns_err_when_no_scope() {
let result = current_tenant_id_or_error();
assert!(
result.is_err(),
"无 scope 时应 fail-closed 返回 Err: {:?}",
result.ok()
);
match result {
Err(GarrisonError::Config(msg)) => {
assert!(
msg.contains("ctx-tenant-context-missing") || msg.contains("租户隔离"),
"错误消息应含 'ctx-tenant-context-missing' 或 '租户隔离',实际: {}",
msg
);
},
Err(other) => panic!("期望 Config 错误,实际: {:?}", other),
Ok(_) => panic!("期望 Err(fail-closed),实际 Ok"),
}
}
#[tokio::test]
async fn or_error_returns_ok_with_scope() {
let ctx = TenantContext {
tenant_id: 42,
resolved_from: TenantSource::Header,
};
let result = TENANT
.scope(ctx, async { current_tenant_id_or_error() })
.await;
assert!(result.is_ok(), "scope 内应返回 Ok: {:?}", result.err());
assert_eq!(result.unwrap(), 42);
}
#[tokio::test]
async fn or_error_handles_various_tenant_ids() {
let ctx0 = TenantContext {
tenant_id: 0,
resolved_from: TenantSource::Header,
};
let result0 = TENANT
.scope(ctx0, async { current_tenant_id_or_error() })
.await;
assert!(result0.is_ok(), "tenant_id=0 + scope 应 Ok");
assert_eq!(result0.unwrap(), 0);
let ctx_max = TenantContext {
tenant_id: i64::MAX,
resolved_from: TenantSource::Header,
};
let result_max = TENANT
.scope(ctx_max, async { current_tenant_id_or_error() })
.await;
assert!(result_max.is_ok());
assert_eq!(result_max.unwrap(), i64::MAX);
}
#[tokio::test]
async fn subdomain_tenant_resolver_extracts_from_host() {
let mut headers = http::HeaderMap::new();
headers.insert("Host", "tenant42.example.com".parse().unwrap());
let resolver = SubdomainTenantResolver {
mapping: std::collections::HashMap::from([("tenant42".to_string(), 42)]),
};
let ctx = resolver
.resolve(&headers)
.await
.expect("Host 含已知 subdomain 时应解析成功");
assert_eq!(ctx.tenant_id, 42);
assert!(matches!(ctx.resolved_from, TenantSource::Subdomain));
}
#[tokio::test]
async fn subdomain_tenant_resolver_returns_config_error_when_mapping_miss() {
let mut headers = http::HeaderMap::new();
headers.insert("Host", "unknown.example.com".parse().unwrap());
let resolver = SubdomainTenantResolver {
mapping: std::collections::HashMap::from([("tenant42".to_string(), 42)]),
};
let result = resolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::Config(_))));
}
#[tokio::test]
async fn subdomain_tenant_resolver_returns_config_error_when_host_missing() {
let headers = http::HeaderMap::new();
let resolver = SubdomainTenantResolver {
mapping: std::collections::HashMap::new(),
};
let result = resolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::Config(_))));
}
#[tokio::test]
async fn subdomain_tenant_resolver_strips_port_from_host() {
let mut headers = http::HeaderMap::new();
headers.insert("Host", "tenant42.example.com:8080".parse().unwrap());
let resolver = SubdomainTenantResolver {
mapping: std::collections::HashMap::from([("tenant42".to_string(), 42)]),
};
let ctx = resolver
.resolve(&headers)
.await
.expect("带端口的 Host 应正确提取 subdomain");
assert_eq!(ctx.tenant_id, 42);
}
#[tokio::test]
async fn subdomain_tenant_resolver_handles_ipv6_host_without_panic() {
let mut headers = http::HeaderMap::new();
headers.insert("Host", "[::1]:8080".parse().unwrap());
let resolver = SubdomainTenantResolver {
mapping: std::collections::HashMap::from([("tenant42".to_string(), 42)]),
};
let result = resolver.resolve(&headers).await;
match result {
Err(GarrisonError::Config(msg)) => {
assert!(
msg.contains("ctx-host-unknown-subdomain"),
"IPv6 Host 应走 unknown-subdomain 路径,实际: {msg}"
);
assert!(
msg.contains("::1"),
"错误消息应包含完整 IPv6 地址而非 '[',实际: {msg}"
);
},
Err(other) => panic!("期望 Config 错误,实际: {:?}", other),
Ok(_) => panic!("IPv6 地址不在 mapping 中应报错"),
}
}
#[tokio::test]
async fn subdomain_tenant_resolver_handles_ipv6_host_without_port() {
let mut headers = http::HeaderMap::new();
headers.insert("Host", "[2001:db8::1]".parse().unwrap());
let resolver = SubdomainTenantResolver {
mapping: std::collections::HashMap::new(),
};
let result = resolver.resolve(&headers).await;
assert!(
matches!(result, Err(GarrisonError::Config(_))),
"裸 IPv6 Host 不应 panic,应返回 Config 错误"
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_extracts_from_jwt_claim() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
tenant_id: i64,
exp: i64,
}
let secret = "test-secret-claim";
let claims = Claims {
tenant_id: 42,
exp: 9999999999,
};
let header = Header::new(Algorithm::HS256);
let key = EncodingKey::from_secret(secret.as_bytes());
let jwt = encode(&header, &claims, &key).expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert(
"Authorization",
format!("Bearer {jwt}").parse().expect("valid header value"),
);
let resolver = ClaimTenantResolver::new(secret.to_string());
let ctx = resolver
.resolve(&headers)
.await
.expect("valid JWT 应解析成功");
assert_eq!(ctx.tenant_id, 42);
assert!(matches!(ctx.resolved_from, TenantSource::Claim));
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_returns_invalid_token_when_auth_missing() {
let headers = http::HeaderMap::new();
let resolver = ClaimTenantResolver::new("secret".to_string());
let result = resolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::InvalidToken(_))));
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_returns_invalid_token_when_signature_bad() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
tenant_id: i64,
exp: i64,
}
let signing_secret = "secret-a";
let verifying_secret = "secret-b"; let jwt = encode(
&Header::new(Algorithm::HS256),
&Claims {
tenant_id: 42,
exp: 9999999999,
},
&EncodingKey::from_secret(signing_secret.as_bytes()),
)
.expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert("Authorization", format!("Bearer {jwt}").parse().unwrap());
let resolver = ClaimTenantResolver::new(verifying_secret.to_string());
let result = resolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::InvalidToken(_))));
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_returns_invalid_token_when_claim_missing() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
exp: i64,
}
let secret = "test-secret-no-claim";
let jwt = encode(
&Header::new(Algorithm::HS256),
&Claims { exp: 9999999999 },
&EncodingKey::from_secret(secret.as_bytes()),
)
.expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert("Authorization", format!("Bearer {jwt}").parse().unwrap());
let resolver = ClaimTenantResolver::new(secret.to_string());
let result = resolver.resolve(&headers).await;
assert!(matches!(result, Err(GarrisonError::InvalidToken(_))));
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_accepts_lowercase_bearer_scheme() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
tenant_id: i64,
exp: i64,
}
let secret = "test-secret-lower";
let jwt = encode(
&Header::new(Algorithm::HS256),
&Claims {
tenant_id: 42,
exp: 9999999999,
},
&EncodingKey::from_secret(secret.as_bytes()),
)
.expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert("Authorization", format!("bearer {jwt}").parse().unwrap());
let resolver = ClaimTenantResolver::new(secret.to_string());
let ctx = resolver
.resolve(&headers)
.await
.expect("小写 bearer scheme 应被接受");
assert_eq!(ctx.tenant_id, 42);
}
#[cfg(feature = "protocol-jwt")]
#[test]
fn claim_tenant_resolver_debug_redacts_jwt_secret() {
let resolver = ClaimTenantResolver::new("super-secret-value".to_string());
let debug = format!("{:?}", resolver);
assert!(
!debug.contains("super-secret-value"),
"Debug 输出不得包含明文 jwt_secret,实际: {debug}"
);
assert!(
debug.contains("<redacted>"),
"Debug 输出应包含脱敏占位符,实际: {debug}"
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_rejects_wrong_issuer_when_configured() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
tenant_id: i64,
exp: i64,
iss: String,
}
let secret = "test-secret-issuer";
let jwt = encode(
&Header::new(Algorithm::HS256),
&Claims {
tenant_id: 42,
exp: 9999999999,
iss: "attacker-service".to_string(),
},
&EncodingKey::from_secret(secret.as_bytes()),
)
.expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert("Authorization", format!("Bearer {jwt}").parse().unwrap());
let resolver = ClaimTenantResolver::new(secret.to_string())
.with_expected_issuers(vec!["garrison-auth".to_string()]);
let result = resolver.resolve(&headers).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"iss 不匹配的 JWT 应被拒绝(防跨服务 token 重放)"
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_accepts_matching_issuer_when_configured() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
tenant_id: i64,
exp: i64,
iss: String,
}
let secret = "test-secret-issuer-ok";
let jwt = encode(
&Header::new(Algorithm::HS256),
&Claims {
tenant_id: 7,
exp: 9999999999,
iss: "garrison-auth".to_string(),
},
&EncodingKey::from_secret(secret.as_bytes()),
)
.expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert("Authorization", format!("Bearer {jwt}").parse().unwrap());
let resolver = ClaimTenantResolver::new(secret.to_string())
.with_expected_issuers(vec!["garrison-auth".to_string()]);
let ctx = resolver.resolve(&headers).await.expect("iss 匹配应通过");
assert_eq!(ctx.tenant_id, 7);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn claim_tenant_resolver_rejects_wrong_audience_when_configured() {
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
#[derive(serde::Serialize)]
struct Claims {
tenant_id: i64,
exp: i64,
aud: String,
}
let secret = "test-secret-aud";
let jwt = encode(
&Header::new(Algorithm::HS256),
&Claims {
tenant_id: 42,
exp: 9999999999,
aud: "other-service".to_string(),
},
&EncodingKey::from_secret(secret.as_bytes()),
)
.expect("encode jwt");
let mut headers = http::HeaderMap::new();
headers.insert("Authorization", format!("Bearer {jwt}").parse().unwrap());
let resolver = ClaimTenantResolver::new(secret.to_string())
.with_expected_audiences(vec!["tenant-service".to_string()]);
let result = resolver.resolve(&headers).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"aud 不匹配的 JWT 应被拒绝"
);
}
}