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;
#[deprecated(
since = "0.7.0",
note = "使用 current_tenant_id_strict() 或 current_tenant_id_or_error() 替代,避免租户隔离静默绕过"
)]
pub fn current_tenant_id() -> i64 {
TENANT.try_get().map(|ctx| ctx.tenant_id).unwrap_or(0)
}
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()))
}
#[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("X-Tenant-Id header missing".into()))?;
let raw = value
.to_str()
.map_err(|e| GarrisonError::Config(format!("X-Tenant-Id not visible ASCII: {e}")))?;
let tenant_id = raw
.parse::<i64>()
.map_err(|e| GarrisonError::Config(format!("invalid X-Tenant-Id `{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("Host header missing".into()))?
.to_str()
.map_err(|e| GarrisonError::Config(format!("Host not visible ASCII: {e}")))?;
let hostname = host.split(':').next().unwrap_or(host);
let subdomain = hostname.split('.').next().unwrap_or(hostname);
if subdomain.is_empty() {
return Err(GarrisonError::Config(format!(
"invalid Host `{host}`: empty subdomain"
)));
}
let tenant_id = *self
.mapping
.get(subdomain)
.ok_or_else(|| GarrisonError::Config(format!("unknown subdomain `{subdomain}`")))?;
Ok(TenantContext {
tenant_id,
resolved_from: TenantSource::Subdomain,
})
}
}
#[cfg(feature = "protocol-jwt")]
#[derive(Debug, Clone)]
pub struct ClaimTenantResolver {
pub jwt_secret: String,
}
#[cfg(feature = "protocol-jwt")]
impl ClaimTenantResolver {
pub fn new(jwt_secret: String) -> Self {
Self { jwt_secret }
}
}
#[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("Authorization header missing".into()))?
.to_str()
.map_err(|e| {
GarrisonError::InvalidToken(format!("Authorization not visible ASCII: {e}"))
})?;
let mut parts = auth.splitn(2, ' ');
let scheme = parts
.next()
.ok_or_else(|| GarrisonError::InvalidToken("empty Authorization header".into()))?;
let jwt = parts.next().ok_or_else(|| {
GarrisonError::InvalidToken("missing token in Authorization header".into())
})?;
if !scheme.eq_ignore_ascii_case("Bearer") {
return Err(GarrisonError::InvalidToken(format!(
"unsupported auth scheme `{scheme}` (expected Bearer)"
)));
}
let key = DecodingKey::from_secret(self.jwt_secret.as_bytes());
let mut validation = Validation::new(Algorithm::HS256);
validation.validate_exp = true;
validation.leeway = 0;
let data = decode::<TenantClaims>(jwt, &key, &validation)
.map_err(|e| GarrisonError::InvalidToken(format!("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]
#[allow(deprecated)]
async fn deprecated_current_tenant_id_still_callable_with_allow() {
assert_eq!(current_tenant_id(), 0);
let ctx = TenantContext {
tenant_id: 42,
resolved_from: TenantSource::Header,
};
let result = TENANT.scope(ctx, async { current_tenant_id() }).await;
assert_eq!(result, 42);
}
#[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);
}
#[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);
}
}