use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use std::time::Duration;
use super::types::{
ApiResponse, CheckApiKeyRequest, CheckLoginRequest, CheckPermissionRequest, CheckRoleRequest,
KickoutRequest, LoginParams, LoginRequest, LogoutRequest, RenewToEquivalentRequest,
SessionData, SwitchToRequest, TokenInfo,
};
use super::AuthBackend;
pub struct BackendRemote {
client: reqwest::Client,
base_url: String,
api_key: String,
}
impl BackendRemote {
pub fn new(
base_url: impl Into<String>,
api_key: impl Into<String>,
timeout: Duration,
) -> GarrisonResult<Self> {
let client = reqwest::Client::builder()
.timeout(timeout)
.build()
.map_err(|e| GarrisonError::Network(format!("backend-http-client-build::{}", e)))?;
Ok(Self {
client,
base_url: base_url.into(),
api_key: api_key.into(),
})
}
async fn post<Req, T>(&self, path: &str, req: &Req) -> GarrisonResult<ApiResponse<T>>
where
Req: serde::Serialize,
T: serde::de::DeserializeOwned,
{
let url = format!("{}{}", self.base_url, path);
let resp = self
.client
.post(&url)
.header("X-API-Key", &self.api_key)
.json(req)
.send()
.await
.map_err(|e| GarrisonError::Network(format!("backend-http-request::{}", e)))?;
let status = resp.status();
if !status.is_success() {
let body = resp.text().await.unwrap_or_default();
return Err(GarrisonError::Network(format!(
"HTTP {}: {}",
status.as_u16(),
body
)));
}
resp.json::<ApiResponse<T>>()
.await
.map_err(|e| GarrisonError::Network(format!("backend-response-deser::{}", e)))
}
async fn post_and_extract<Req, T>(&self, path: &str, req: &Req) -> GarrisonResult<T>
where
Req: serde::Serialize,
T: serde::de::DeserializeOwned,
{
let api_resp = self.post::<Req, T>(path, req).await?;
api_resp
.into_result()
.map_err(|(code, _msg)| GarrisonError::Network(format!("backend-api-error::{}", code)))
}
async fn post_unit<Req>(&self, path: &str, req: &Req) -> GarrisonResult<()>
where
Req: serde::Serialize,
{
let api_resp = self.post::<Req, ()>(path, req).await?;
if let Some(code) = api_resp.error_code {
return Err(GarrisonError::Network(format!(
"backend-api-error::{}",
code
)));
}
Ok(())
}
}
#[async_trait]
impl AuthBackend for BackendRemote {
async fn login(&self, login_id: &str, params: &LoginParams) -> GarrisonResult<String> {
let req = LoginRequest {
login_id: login_id.to_string(),
params: params.clone(),
};
self.post_and_extract("/api/v1/auth/login", &req).await
}
async fn logout(&self, token: &str) -> GarrisonResult<()> {
let req = LogoutRequest {
token: token.to_string(),
};
self.post_unit("/api/v1/auth/logout", &req).await
}
async fn check_login(&self, token: &str) -> GarrisonResult<bool> {
let req = CheckLoginRequest {
token: token.to_string(),
};
self.post_and_extract("/api/v1/auth/check-login", &req)
.await
}
async fn check_permission(&self, token: &str, permission: &str) -> GarrisonResult<()> {
let req = CheckPermissionRequest {
token: token.to_string(),
permission: permission.to_string(),
};
self.post_unit("/api/v1/auth/check-permission", &req).await
}
async fn check_role(&self, token: &str, role: &str) -> GarrisonResult<()> {
let req = CheckRoleRequest {
token: token.to_string(),
role: role.to_string(),
};
self.post_unit("/api/v1/auth/check-role", &req).await
}
async fn check_safe(&self, token: &str) -> GarrisonResult<bool> {
let req = CheckLoginRequest {
token: token.to_string(),
};
self.post_and_extract("/api/v1/auth/check-safe", &req).await
}
async fn check_disable(&self, token: &str) -> GarrisonResult<bool> {
let req = CheckLoginRequest {
token: token.to_string(),
};
self.post_and_extract("/api/v1/auth/check-disable", &req)
.await
}
async fn check_api_key(&self, api_key: &str, namespace: &str) -> GarrisonResult<()> {
let req = CheckApiKeyRequest {
api_key: api_key.to_string(),
namespace: namespace.to_string(),
};
self.post_unit("/api/v1/auth/check-api-key", &req).await
}
async fn get_token_info(&self, token: &str) -> GarrisonResult<TokenInfo> {
let req = CheckLoginRequest {
token: token.to_string(),
};
self.post_and_extract("/api/v1/auth/get-token-info", &req)
.await
}
async fn get_session(&self, token: &str) -> GarrisonResult<SessionData> {
let req = CheckLoginRequest {
token: token.to_string(),
};
self.post_and_extract("/api/v1/auth/get-session", &req)
.await
}
async fn kickout(&self, login_id: &str) -> GarrisonResult<()> {
let req = KickoutRequest {
login_id: login_id.to_string(),
};
self.post_unit("/api/v1/auth/kickout", &req).await
}
async fn switch_to(&self, token: &str, target_login_id: &str) -> GarrisonResult<()> {
let req = SwitchToRequest {
token: token.to_string(),
target_login_id: target_login_id.to_string(),
};
self.post_unit("/api/v1/auth/switch-to", &req).await
}
async fn renew_to_equivalent(&self, token: &str) -> GarrisonResult<String> {
let req = RenewToEquivalentRequest {
token: token.to_string(),
};
self.post_and_extract("/api/v1/auth/renew-to-equivalent", &req)
.await
}
}
pub struct BackendRemoteBuilder {
base_url: String,
api_key: String,
timeout: Duration,
client_cert: Option<Vec<u8>>,
client_key: Option<Vec<u8>>,
ca_cert: Option<Vec<u8>>,
}
impl BackendRemoteBuilder {
pub fn new(base_url: impl Into<String>, api_key: impl Into<String>) -> Self {
Self {
base_url: base_url.into(),
api_key: api_key.into(),
timeout: Duration::from_secs(30),
client_cert: None,
client_key: None,
ca_cert: None,
}
}
pub fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub fn with_client_cert(mut self, cert_pem: Vec<u8>, key_pem: Vec<u8>) -> Self {
self.client_cert = Some(cert_pem);
self.client_key = Some(key_pem);
self
}
pub fn with_ca_cert(mut self, ca_pem: Vec<u8>) -> Self {
self.ca_cert = Some(ca_pem);
self
}
pub fn build(self) -> GarrisonResult<BackendRemote> {
let mut builder = reqwest::Client::builder().timeout(self.timeout);
if let Some(ca_pem) = self.ca_cert {
let cert = reqwest::Certificate::from_pem(&ca_pem)
.map_err(|e| GarrisonError::Network(format!("backend-ca-load::{}", e)))?;
builder = builder.add_root_certificate(cert);
}
if let (Some(cert_pem), Some(key_pem)) = (self.client_cert, self.client_key) {
let mut combined = cert_pem;
combined.extend_from_slice(&key_pem);
let identity = reqwest::Identity::from_pem(&combined)
.map_err(|e| GarrisonError::Network(format!("backend-client-cert-load::{}", e)))?;
builder = builder.identity(identity);
}
let client = builder
.build()
.map_err(|e| GarrisonError::Network(format!("backend-http-client-build::{}", e)))?;
Ok(BackendRemote {
client,
base_url: self.base_url,
api_key: self.api_key,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use wiremock::matchers::{header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
async fn setup_remote() -> (MockServer, BackendRemote) {
let server = MockServer::start().await;
let remote =
BackendRemote::new(server.uri(), "test-api-key", Duration::from_secs(5)).unwrap();
(server, remote)
}
#[tokio::test]
async fn test_check_login_returns_true() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-login"))
.and(header("X-API-Key", "test-api-key"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": true,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let result = remote.check_login("valid-token").await.unwrap();
assert!(result);
}
#[tokio::test]
async fn test_check_login_returns_false() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-login"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": false,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let result = remote.check_login("invalid-token").await.unwrap();
assert!(!result);
}
#[tokio::test]
async fn test_login_returns_token() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/login"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": "generated-token-123",
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let token = remote
.login("user1", &LoginParams::default())
.await
.unwrap();
assert_eq!(token, "generated-token-123");
}
#[tokio::test]
async fn test_logout_succeeds() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/logout"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
remote.logout("some-token").await.unwrap();
}
#[tokio::test]
async fn test_check_permission_succeeds() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-permission"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
remote.check_permission("token", "user:read").await.unwrap();
}
#[tokio::test]
async fn test_check_permission_api_error() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-permission"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": "NOT_PERMISSION",
"message": "无权限"
})))
.mount(&server)
.await;
let result = remote.check_permission("token", "user:read").await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_check_role_succeeds() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-role"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
remote.check_role("token", "admin").await.unwrap();
}
#[tokio::test]
async fn test_check_safe_returns_true() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-safe"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": true,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
assert!(remote.check_safe("token").await.unwrap());
}
#[tokio::test]
async fn test_check_disable_returns_false() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-disable"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": false,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
assert!(!remote.check_disable("token").await.unwrap());
}
#[tokio::test]
async fn test_check_api_key_succeeds() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-api-key"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
remote.check_api_key("api-key", "default").await.unwrap();
}
#[tokio::test]
async fn test_get_token_info() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/get-token-info"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": {
"token": "test-token",
"created_at": 1000,
"last_active_at": 2000
},
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let info = remote.get_token_info("test-token").await.unwrap();
assert_eq!(info.token, "test-token");
assert_eq!(info.created_at, 1000);
assert_eq!(info.last_active_at, 2000);
}
#[tokio::test]
async fn test_get_session() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/get-session"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": {
"token": "test-token",
"login_id": "user1",
"created_at": 1000,
"last_active_at": 2000,
"attrs": {},
"device": null,
"ip": null,
"user_agent": null,
"safe_services": {}
},
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let session = remote.get_session("test-token").await.unwrap();
assert_eq!(session.token, "test-token");
assert_eq!(session.login_id, "user1");
}
#[tokio::test]
async fn test_kickout_succeeds() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/kickout"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
remote.kickout("user1").await.unwrap();
}
#[tokio::test]
async fn test_switch_to_succeeds() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/switch-to"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
remote.switch_to("token", "user2").await.unwrap();
}
#[tokio::test]
async fn test_renew_to_equivalent_returns_new_token() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/renew-to-equivalent"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": "new-token-456",
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let new_token = remote.renew_to_equivalent("old-token").await.unwrap();
assert_eq!(new_token, "new-token-456");
}
#[tokio::test]
async fn test_network_error_connection_refused() {
let remote =
BackendRemote::new("http://127.0.0.1:1", "api-key", Duration::from_secs(1)).unwrap();
let result = remote.check_login("token").await;
assert!(result.is_err());
match result.unwrap_err() {
GarrisonError::Network(_) => {},
e => panic!("期望 Network 错误,实际: {:?}", e),
}
}
#[tokio::test]
async fn test_http_500_error() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-login"))
.respond_with(ResponseTemplate::new(500))
.mount(&server)
.await;
let result = remote.check_login("token").await;
assert!(result.is_err());
match result.unwrap_err() {
GarrisonError::Network(_) => {},
e => panic!("期望 Network 错误,实际: {:?}", e),
}
}
#[tokio::test]
async fn test_api_error_response() {
let (server, remote) = setup_remote().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-login"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": "INVALID_TOKEN",
"message": "token 已过期"
})))
.mount(&server)
.await;
let result = remote.check_login("token").await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_builder_basic() {
let (server, _remote) = setup_remote().await;
let remote = BackendRemoteBuilder::new(server.uri(), "builder-key")
.with_timeout(Duration::from_secs(10))
.build()
.unwrap();
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-login"))
.and(header("X-API-Key", "builder-key"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": true,
"error_code": null,
"message": null
})))
.mount(&server)
.await;
assert!(remote.check_login("token").await.unwrap());
}
#[tokio::test]
async fn test_builder_with_ca_cert() {
let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_string()]).unwrap();
let ca_pem = cert.cert.der().clone();
let _ca_cert = reqwest::Certificate::from_der(&ca_pem).unwrap();
let result = BackendRemoteBuilder::new("https://localhost:8443", "key")
.with_ca_cert(cert.cert.pem().as_bytes().to_vec())
.build();
assert!(result.is_ok());
}
#[tokio::test]
async fn test_dyn_dispatch_with_backend_remote() {
let (server, remote) = setup_remote().await;
let backend: Arc<dyn AuthBackend> = Arc::new(remote);
Mock::given(method("POST"))
.and(path("/api/v1/auth/login"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": "dyn-token",
"error_code": null,
"message": null
})))
.mount(&server)
.await;
let token = backend
.login("user", &LoginParams::default())
.await
.unwrap();
assert_eq!(token, "dyn-token");
}
}