rskit-messaging 0.2.0-alpha.3

Message broker abstractions, registry, middleware, and in-memory adapter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

//! Error classification for retry and circuit-breaker decisions.

use rskit_errors::AppError;

/// Classifies errors for retry and circuit-breaker decisions.
///
/// Broker adapters implement this trait so that generic retry policies
/// and circuit breakers can decide how to handle a particular failure without knowing which broker produced it.
pub trait ErrorClassifier: Send + Sync {
    /// Returns `true` when the error indicates the broker connection is down (e.g. TCP reset, DNS failure, authentication timeout).
    fn is_connection_error(&self, err: &AppError) -> bool;

    /// Returns `true` when the error is transient
    /// and the operation can be retried (e.g. leader election in progress, throttling, temporary I/O error).
    /// Connection errors are typically retryable too,
    /// but the distinction lets callers apply different back-off strategies.
    fn is_retryable_error(&self, err: &AppError) -> bool;
}

/// A no-op classifier that considers every error non-retryable.
///
/// Useful as a default when no broker-specific classifier is available.
#[derive(Debug, Clone, Copy, Default)]
pub struct NoopErrorClassifier;

impl ErrorClassifier for NoopErrorClassifier {
    fn is_connection_error(&self, _err: &AppError) -> bool {
        false
    }

    fn is_retryable_error(&self, _err: &AppError) -> bool {
        false
    }
}

#[cfg(test)]
mod tests {
    use rskit_errors::{AppError, ErrorCode};

    use super::*;

    #[test]
    fn noop_classifier_returns_false() {
        let classifier = NoopErrorClassifier;
        let err = AppError::new(ErrorCode::Internal, "something broke");

        assert!(!classifier.is_connection_error(&err));
        assert!(!classifier.is_retryable_error(&err));
    }
}