sharedstate 2.0.0

Sync heavily read state across many servers
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

//! End-to-end fixed-leader sync tests over real TCP.

mod support;

use sharedstate::{FollowerStatus, NodeStatus};
use support::{init_tracing, TestCluster};

#[tokio::test(flavor = "multi_thread")]
async fn follower_actions_apply_through_fixed_leader_over_tcp() {
    init_tracing();

    let cluster = TestCluster::start(2).await;
    cluster.wait_connected_to_leader(1).await;

    cluster.submit(1, "from-follower", "1").await;
    cluster.wait_all_for_value("from-follower", "1").await;

    cluster.submit(0, "from-leader", "2").await;
    cluster.wait_all_for_value("from-leader", "2").await;
}

#[tokio::test(flavor = "multi_thread")]
async fn debug_info_reports_leadership_and_subscription_peer() {
    init_tracing();

    let cluster = TestCluster::start(2).await;
    cluster.wait_connected_to_leader(1).await;

    let leader = cluster.debug_info(0);
    assert_eq!(leader.my_address, cluster.address(0));
    assert_eq!(leader.leader_address, cluster.address(0));
    assert_eq!(leader.status, NodeStatus::Leader);
    assert!(leader.is_leader());
    assert!(leader.is_connected_to_leader());
    assert!(!leader.is_subscribed_to_leader());
    assert_eq!(leader.connected_peer(), None);
    assert_eq!(leader.available_peers.len(), 2);

    let follower = cluster.debug_info(1);
    assert_eq!(follower.my_address, cluster.address(1));
    assert_eq!(follower.leader_address, cluster.address(0));
    assert_eq!(follower.status, NodeStatus::Follower(FollowerStatus::SubscribedToLeader));
    assert!(!follower.is_leader());
    assert!(follower.is_connected_to_leader());
    assert!(follower.is_subscribed_to_leader());
    assert_eq!(follower.connected_peer(), Some(cluster.address(0)));
    assert_eq!(follower.available_peers.len(), 2);
}