d-engine-server 0.2.3

Production-ready Raft consensus engine server and runtime
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use tracing_test::traced_test;

use super::*;
use d_engine_proto::server::cluster::ClusterConfUpdateResponse;
use d_engine_proto::server::cluster::cluster_conf_update_response::ErrorCode;

async fn async_ok(
    number: u64
) -> std::result::Result<tonic::Response<ClusterConfUpdateResponse>, tonic::Status> {
    sleep(Duration::from_millis(number)).await;
    let c = ClusterConfUpdateResponse {
        id: 1,
        term: 1,
        version: 1,
        success: true,
        error_code: ErrorCode::Unspecified.into(),
    };
    let response: tonic::Response<ClusterConfUpdateResponse> = tonic::Response::new(c);
    Ok(response)
}

async fn async_err()
-> std::result::Result<tonic::Response<ClusterConfUpdateResponse>, tonic::Status> {
    sleep(Duration::from_millis(100)).await;
    Err(tonic::Status::aborted("message"))
}

#[tokio::test]
#[traced_test]
async fn test_rpc_task_with_exponential_backoff() {
    tokio::time::pause();

    // Case 1: when ok task return ok
    let policy = BackoffPolicy {
        max_retries: 3,
        timeout_ms: 100,
        base_delay_ms: 1000,
        max_delay_ms: 3000,
    };

    assert!(
        grpc_task_with_timeout_and_exponential_backoff(
            "test_rpc_task_with_exponential_backoff",
            || async { async_ok(3).await },
            policy,
        )
        .await
        .is_ok()
    );

    // Case 2: when err task return error
    assert!(
        grpc_task_with_timeout_and_exponential_backoff(
            "test_rpc_task_with_exponential_backoff",
            async_err,
            policy
        )
        .await
        .is_err()
    );

    // Case 3: when ok task always failed on timeout error
    let policy = BackoffPolicy {
        max_retries: 3,
        timeout_ms: 1,
        base_delay_ms: 1,
        max_delay_ms: 3,
    };
    assert!(
        grpc_task_with_timeout_and_exponential_backoff(
            "test_rpc_task_with_exponential_backoff",
            || async { async_ok(3).await },
            policy
        )
        .await
        .is_err()
    );
}