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
use crate::consensus::*;
use snarkos_consensus::{MemoryPool, MerkleTreeLedger};
use snarkos_dpc::base_dpc::{instantiated::Components, parameters::PublicParameters};
use snarkos_network::{Channel, Context, Server, SyncHandler};
use rand::Rng;
use std::{net::SocketAddr, sync::Arc};
use tokio::{net::TcpListener, sync::Mutex};
pub const LOCALHOST: &'static str = "0.0.0.0:";
pub const CONNECTION_FREQUENCY_LONG: u64 = 100000;
pub const CONNECTION_FREQUENCY_SHORT: u64 = 100;
pub const CONNECTION_FREQUENCY_SHORT_TIMEOUT: u64 = 200;
pub fn random_socket_address() -> SocketAddr {
let mut rng = rand::thread_rng();
let string = format!("{}{}", LOCALHOST, rng.gen_range(1023, 9999));
string.parse::<SocketAddr>().unwrap()
}
pub async fn sleep(time: u64) {
tokio::time::delay_for(std::time::Duration::from_millis(time)).await;
}
pub fn initialize_test_server(
server_address: SocketAddr,
bootnode_address: SocketAddr,
storage: Arc<MerkleTreeLedger>,
parameters: PublicParameters<Components>,
connection_frequency: u64,
) -> Server {
let consensus = TEST_CONSENSUS.clone();
let memory_pool = MemoryPool::new();
let memory_pool_lock = Arc::new(Mutex::new(memory_pool));
let sync_handler = SyncHandler::new(bootnode_address);
let sync_handler_lock = Arc::new(Mutex::new(sync_handler));
Server::new(
Context::new(server_address, 5, 1, 10, true, vec![]),
consensus,
storage,
parameters,
memory_pool_lock,
sync_handler_lock,
connection_frequency,
)
}
pub fn start_test_server(server: Server) {
tokio::spawn(async move { server.listen().await.unwrap() });
}
pub async fn connect_channel(listener: &mut TcpListener, address: SocketAddr) -> Channel {
let channel = Channel::new_write_only(address).await.unwrap();
let (reader, _socket) = listener.accept().await.unwrap();
channel.update_reader(Arc::new(Mutex::new(reader)))
}
pub async fn accept_channel(listener: &mut TcpListener, address: SocketAddr) -> Channel {
let (reader, _peer) = listener.accept().await.unwrap();
let channel = Channel::new_read_only(reader).unwrap();
channel.update_writer(address).await.unwrap()
}
pub async fn simulate_active_node(address: SocketAddr) {
accept_all_messages(TcpListener::bind(address).await.unwrap());
}
pub fn accept_all_messages(mut peer_listener: TcpListener) {
tokio::spawn(async move {
loop {
peer_listener.accept().await.unwrap();
}
});
}