use crate::error::{GarrisonError, GarrisonResult};
use limiteron::circuit::{
CircuitBreaker, CircuitBreakerConfig, CircuitCallError, FailureClassifier,
};
use limiteron::error::LimiteronError;
use std::sync::Arc;
#[derive(Debug)]
struct GarrisonErrorClassifier;
impl FailureClassifier<LimiteronError> for GarrisonErrorClassifier {
fn is_counted_as_failure(&self, error: &LimiteronError) -> bool {
match error {
LimiteronError::StorageError(storage_err) => storage_err.is_transient(),
LimiteronError::LimitError(_) | LimiteronError::CircuitBreakerError(_) => false,
LimiteronError::ValidationError(_) => false,
_ => true,
}
}
}
fn to_limiteron_error(e: GarrisonError) -> LimiteronError {
match &e {
GarrisonError::Network(msg) => LimiteronError::StorageError(
limiteron::error::StorageError::ConnectionError(msg.clone()),
),
GarrisonError::Dao(msg) => {
LimiteronError::StorageError(limiteron::error::StorageError::QueryError(msg.clone()))
},
GarrisonError::InvalidParam(msg)
| GarrisonError::NotLogin(msg)
| GarrisonError::NotPermission(msg)
| GarrisonError::NotRole(msg)
| GarrisonError::InvalidToken(msg) => LimiteronError::ValidationError(msg.clone()),
_ => LimiteronError::Other(format!("{}", e)),
}
}
fn to_garrison_error(e: LimiteronError) -> GarrisonError {
match &e {
LimiteronError::CircuitBreakerError(msg) => {
GarrisonError::Network(format!("circuit-open::{}", msg))
},
LimiteronError::StorageError(limiteron::error::StorageError::ConnectionError(msg)) => {
GarrisonError::Network(msg.clone())
},
LimiteronError::LimitError(msg) => {
GarrisonError::FirewallBlocked(format!("circuit-limited::{}", msg))
},
_ => GarrisonError::Internal(format!("circuit-breaker::{}", e)),
}
}
pub struct CircuitBreakerWrapper {
inner: CircuitBreaker,
}
impl CircuitBreakerWrapper {
pub fn new(config: CircuitBreakerConfig) -> Self {
let config = config.error_classifier(Arc::new(GarrisonErrorClassifier));
Self {
inner: CircuitBreaker::new(config),
}
}
pub async fn execute<F, Fut, T>(&self, operation: F) -> GarrisonResult<T>
where
F: FnOnce() -> Fut,
Fut: std::future::Future<Output = GarrisonResult<T>>,
{
self.inner
.execute(|| async { operation().await.map_err(to_limiteron_error) })
.await
.map_err(|call_err| match call_err {
CircuitCallError::Open => {
GarrisonError::Network("circuit-open::circuit breaker is open".to_string())
},
CircuitCallError::Inner(e) => to_garrison_error(e),
})
}
pub async fn is_open(&self) -> bool {
self.inner.is_open().await
}
pub async fn state(&self) -> limiteron::error::CircuitState {
self.inner.get_state().await
}
pub async fn reset(&self) {
self.inner.reset().await;
}
pub fn inner(&self) -> &CircuitBreaker {
&self.inner
}
}
impl std::fmt::Debug for CircuitBreakerWrapper {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CircuitBreakerWrapper")
.finish_non_exhaustive()
}
}
#[cfg(test)]
mod tests {
use super::*;
use limiteron::circuit::CircuitBreakerConfig;
use std::time::Duration;
fn make_config() -> CircuitBreakerConfig {
CircuitBreakerConfig::new(3, 2, Duration::from_secs(60))
}
#[tokio::test]
async fn initial_state_closed() {
let wrapper = CircuitBreakerWrapper::new(make_config());
assert!(!wrapper.is_open().await);
}
#[tokio::test]
async fn success_does_not_trip() {
let wrapper = CircuitBreakerWrapper::new(make_config());
let result = wrapper
.execute(|| async { Ok::<_, GarrisonError>(42) })
.await;
assert_eq!(result.unwrap(), 42);
assert!(!wrapper.is_open().await);
}
#[tokio::test]
async fn network_errors_trip_breaker() {
let wrapper = CircuitBreakerWrapper::new(make_config());
for _ in 0..3 {
let _ = wrapper
.execute(|| async {
Err::<(), _>(GarrisonError::Network("connection refused".into()))
})
.await;
}
assert!(wrapper.is_open().await, "3 次 Network 错误后应熔断");
}
#[tokio::test]
async fn open_breaker_rejects_immediately() {
let wrapper = CircuitBreakerWrapper::new(make_config());
for _ in 0..3 {
let _ = wrapper
.execute(|| async { Err::<(), _>(GarrisonError::Network("timeout".into())) })
.await;
}
assert!(wrapper.is_open().await);
let result = wrapper
.execute(|| async { Ok::<_, GarrisonError>(42) })
.await;
assert!(result.is_err(), "熔断器打开时应拒绝请求");
let err = result.unwrap_err();
assert!(
matches!(&err, GarrisonError::Network(m) if m.starts_with("circuit-open::")),
"熔断拒绝应为 circuit-open:: 前缀的 Network 错误,实际: {err:?}"
);
}
#[tokio::test]
async fn client_errors_not_counted() {
let config = CircuitBreakerConfig::new(2, 1, Duration::from_secs(60));
let wrapper = CircuitBreakerWrapper::new(config);
for _ in 0..5 {
let _ = wrapper
.execute(|| async { Err::<(), _>(GarrisonError::InvalidParam("bad input".into())) })
.await;
}
assert!(!wrapper.is_open().await, "客户端错误不应触发熔断");
}
#[tokio::test]
async fn reset_restores() {
let wrapper = CircuitBreakerWrapper::new(make_config());
for _ in 0..3 {
let _ = wrapper
.execute(|| async { Err::<(), _>(GarrisonError::Network("err".into())) })
.await;
}
assert!(wrapper.is_open().await);
wrapper.reset().await;
assert!(!wrapper.is_open().await);
}
#[test]
fn debug_impl() {
let wrapper = CircuitBreakerWrapper::new(make_config());
let debug = format!("{:?}", wrapper);
assert!(debug.contains("CircuitBreakerWrapper"));
}
}