ipfs 0.2.1

IPFS node implementation
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

pub mod interop;

use ipfs::Node;

/// The way in which nodes are connected to each other; to be used with spawn_nodes.
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Topology {
    /// no connections
    None,
    /// a > b > c
    Line,
    /// a > b > c > a
    Ring,
    /// a <> b <> c <> a
    Mesh,
    /// a > b, a > c
    Star,
}

#[allow(dead_code)]
pub async fn spawn_nodes(count: usize, topology: Topology) -> Vec<Node> {
    let mut nodes = Vec::with_capacity(count);

    for i in 0..count {
        let node = Node::new(i.to_string()).await;
        nodes.push(node);
    }

    match topology {
        Topology::Line | Topology::Ring => {
            for i in 0..(count - 1) {
                nodes[i]
                    .connect(nodes[i + 1].addrs[0].clone())
                    .await
                    .unwrap();
            }
            if topology == Topology::Ring {
                nodes[count - 1]
                    .connect(nodes[0].addrs[0].clone())
                    .await
                    .unwrap();
            }
        }
        Topology::Mesh => {
            for i in 0..count {
                for (j, peer) in nodes.iter().enumerate() {
                    if i != j {
                        nodes[i].connect(peer.addrs[0].clone()).await.unwrap();
                    }
                }
            }
        }
        Topology::Star => {
            for node in nodes.iter().skip(1) {
                nodes[0].connect(node.addrs[0].clone()).await.unwrap();
            }
        }
        Topology::None => {}
    }

    nodes
}

#[cfg(test)]
mod tests {
    use super::*;

    const N: usize = 5;

    #[tokio::test(max_threads = 1)]
    async fn check_topology_line() {
        let nodes = spawn_nodes(N, Topology::Line).await;

        for (i, node) in nodes.iter().enumerate() {
            if i == 0 || i == N - 1 {
                assert_eq!(node.peers().await.unwrap().len(), 1);
            } else {
                assert_eq!(node.peers().await.unwrap().len(), 2);
            }
        }
    }

    #[tokio::test(max_threads = 1)]
    async fn check_topology_ring() {
        let nodes = spawn_nodes(N, Topology::Ring).await;

        for node in &nodes {
            assert_eq!(node.peers().await.unwrap().len(), 2);
        }
    }

    #[tokio::test(max_threads = 1)]
    async fn check_topology_mesh() {
        let nodes = spawn_nodes(N, Topology::Mesh).await;

        for node in &nodes {
            assert_eq!(node.peers().await.unwrap().len(), N - 1);
        }
    }

    #[tokio::test(max_threads = 1)]
    async fn check_topology_star() {
        let nodes = spawn_nodes(N, Topology::Star).await;

        for (i, node) in nodes.iter().enumerate() {
            if i == 0 {
                assert_eq!(node.peers().await.unwrap().len(), N - 1);
            } else {
                assert_eq!(node.peers().await.unwrap().len(), 1);
            }
        }
    }
}