2018-05-11 23:31:32 -07:00
|
|
|
//! The `tvu` module implements the Transaction Validation Unit, a
|
|
|
|
//! 5-stage transaction validation pipeline in software.
|
2018-05-23 07:11:11 -07:00
|
|
|
//! 1. streamer
|
|
|
|
//! - Incoming blobs are picked up from the replicate socket.
|
|
|
|
//! 2. verifier
|
|
|
|
//! - TODO Blobs are sent to the GPU, and while the memory is there the PoH stream is verified
|
2018-05-23 08:29:24 -07:00
|
|
|
//! along with the ecdsa signature for the blob and each signature in all the transactions. Blobs
|
|
|
|
//! with errors are dropped, or marked for slashing.
|
2018-05-23 07:11:11 -07:00
|
|
|
//! 3.a retransmit
|
|
|
|
//! - Blobs originating from the parent (leader atm is the only parent), are retransmit to all the
|
|
|
|
//! peers in the crdt. Peers is everyone who is not me or the leader that has a known replicate
|
|
|
|
//! address.
|
|
|
|
//! 3.b window
|
|
|
|
//! - Verified blobs are placed into a window, indexed by the counter set by the leader. This could
|
|
|
|
//! be the PoH counter if its monitonically increasing in each blob. Easure coding is used to
|
|
|
|
//! recover any missing packets, and requests are made at random to peers and parents to retransmit
|
|
|
|
//! a missing packet.
|
|
|
|
//! 4. accountant
|
|
|
|
//! - Contigous blobs are sent to the accountant for processing transactions
|
|
|
|
//! 5. validator
|
|
|
|
//! - TODO Validation messages are sent back to the leader
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-05-14 14:33:11 -07:00
|
|
|
use bank::Bank;
|
2018-05-11 23:31:32 -07:00
|
|
|
use crdt::{Crdt, ReplicatedData};
|
|
|
|
use packet;
|
2018-05-22 15:17:59 -07:00
|
|
|
use replicate_stage::ReplicateStage;
|
2018-05-11 23:31:32 -07:00
|
|
|
use std::net::UdpSocket;
|
2018-05-22 15:17:59 -07:00
|
|
|
use std::sync::atomic::AtomicBool;
|
2018-05-14 15:27:40 -07:00
|
|
|
use std::sync::mpsc::channel;
|
2018-05-11 23:31:32 -07:00
|
|
|
use std::sync::{Arc, RwLock};
|
2018-05-22 15:17:59 -07:00
|
|
|
use std::thread::JoinHandle;
|
2018-05-11 23:31:32 -07:00
|
|
|
use streamer;
|
|
|
|
|
|
|
|
pub struct Tvu {
|
2018-05-23 07:11:11 -07:00
|
|
|
pub thread_hdls: Vec<JoinHandle<()>>,
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Tvu {
|
|
|
|
/// This service receives messages from a leader in the network and processes the transactions
|
2018-05-14 14:33:11 -07:00
|
|
|
/// on the bank state.
|
2018-05-11 23:31:32 -07:00
|
|
|
/// # Arguments
|
2018-05-23 07:11:11 -07:00
|
|
|
/// * `bank` - The bank state.
|
2018-05-11 23:31:32 -07:00
|
|
|
/// * `me` - my configuration
|
2018-05-23 07:11:11 -07:00
|
|
|
/// * `gossip` - my gosisp socket
|
|
|
|
/// * `replicte` - my replicte socket
|
2018-05-11 23:31:32 -07:00
|
|
|
/// * `leader` - leader configuration
|
|
|
|
/// * `exit` - The exit signal.
|
2018-05-23 07:11:11 -07:00
|
|
|
pub fn new(
|
|
|
|
bank: Arc<Bank>,
|
2018-05-11 23:31:32 -07:00
|
|
|
me: ReplicatedData,
|
|
|
|
gossip: UdpSocket,
|
|
|
|
replicate: UdpSocket,
|
|
|
|
leader: ReplicatedData,
|
|
|
|
exit: Arc<AtomicBool>,
|
2018-05-23 07:11:11 -07:00
|
|
|
) -> Self {
|
2018-05-11 23:31:32 -07:00
|
|
|
//replicate pipeline
|
|
|
|
let crdt = Arc::new(RwLock::new(Crdt::new(me)));
|
|
|
|
crdt.write()
|
|
|
|
.expect("'crdt' write lock in pub fn replicate")
|
|
|
|
.set_leader(leader.id);
|
|
|
|
crdt.write()
|
|
|
|
.expect("'crdt' write lock before insert() in pub fn replicate")
|
2018-05-12 19:00:22 -07:00
|
|
|
.insert(&leader);
|
2018-05-11 23:31:32 -07:00
|
|
|
let t_gossip = Crdt::gossip(crdt.clone(), exit.clone());
|
2018-05-12 19:00:22 -07:00
|
|
|
let window = streamer::default_window();
|
|
|
|
let t_listen = Crdt::listen(crdt.clone(), window.clone(), gossip, exit.clone());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-05-23 08:29:24 -07:00
|
|
|
// TODO pull this socket out through the public interface
|
2018-05-11 23:31:32 -07:00
|
|
|
// make sure we are on the same interface
|
2018-05-23 08:29:24 -07:00
|
|
|
let mut local = replicate.local_addr().expect("tvu: get local address");
|
2018-05-11 23:31:32 -07:00
|
|
|
local.set_port(0);
|
2018-05-23 08:29:24 -07:00
|
|
|
let write = UdpSocket::bind(local).expect("tvu: bind to local socket");
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
let blob_recycler = packet::BlobRecycler::default();
|
|
|
|
let (blob_sender, blob_receiver) = channel();
|
|
|
|
let t_blob_receiver = streamer::blob_receiver(
|
|
|
|
exit.clone(),
|
|
|
|
blob_recycler.clone(),
|
|
|
|
replicate,
|
|
|
|
blob_sender.clone(),
|
2018-05-23 08:29:24 -07:00
|
|
|
).expect("tvu: blob receiver creation");
|
2018-05-11 23:31:32 -07:00
|
|
|
let (window_sender, window_receiver) = channel();
|
|
|
|
let (retransmit_sender, retransmit_receiver) = channel();
|
|
|
|
|
|
|
|
let t_retransmit = streamer::retransmitter(
|
|
|
|
write,
|
|
|
|
exit.clone(),
|
|
|
|
crdt.clone(),
|
|
|
|
blob_recycler.clone(),
|
|
|
|
retransmit_receiver,
|
|
|
|
);
|
|
|
|
|
|
|
|
//TODO
|
|
|
|
//the packets coming out of blob_receiver need to be sent to the GPU and verified
|
|
|
|
//then sent to the window, which does the erasure coding reconstruction
|
|
|
|
let t_window = streamer::window(
|
|
|
|
exit.clone(),
|
|
|
|
crdt.clone(),
|
2018-05-12 19:00:22 -07:00
|
|
|
window,
|
2018-05-11 23:31:32 -07:00
|
|
|
blob_recycler.clone(),
|
|
|
|
blob_receiver,
|
|
|
|
window_sender,
|
|
|
|
retransmit_sender,
|
|
|
|
);
|
|
|
|
|
2018-05-22 15:17:59 -07:00
|
|
|
let replicate_stage = ReplicateStage::new(
|
2018-05-23 08:29:24 -07:00
|
|
|
bank.clone(),
|
2018-05-22 15:17:59 -07:00
|
|
|
exit.clone(),
|
|
|
|
window_receiver,
|
|
|
|
blob_recycler.clone(),
|
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-05-23 07:11:11 -07:00
|
|
|
let threads = vec![
|
2018-05-11 23:31:32 -07:00
|
|
|
//replicate threads
|
|
|
|
t_blob_receiver,
|
|
|
|
t_retransmit,
|
|
|
|
t_window,
|
2018-05-22 15:17:59 -07:00
|
|
|
replicate_stage.thread_hdl,
|
2018-05-11 23:31:32 -07:00
|
|
|
t_gossip,
|
|
|
|
t_listen,
|
|
|
|
];
|
2018-05-23 08:29:24 -07:00
|
|
|
Tvu{thread_hdls: threads}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-23 08:29:24 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
use std::time::Duration;
|
|
|
|
|
2018-05-11 23:31:32 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
pub fn test_node() -> (ReplicatedData, UdpSocket, UdpSocket, UdpSocket, UdpSocket) {
|
|
|
|
use signature::{KeyPair, KeyPairUtil};
|
|
|
|
|
|
|
|
let events_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
|
|
let gossip = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
|
|
let replicate = UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
|
|
let requests_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
|
2018-05-15 08:42:28 -07:00
|
|
|
requests_socket
|
|
|
|
.set_read_timeout(Some(Duration::new(1, 0)))
|
|
|
|
.unwrap();
|
2018-05-11 23:31:32 -07:00
|
|
|
let pubkey = KeyPair::new().pubkey();
|
|
|
|
let d = ReplicatedData::new(
|
|
|
|
pubkey,
|
|
|
|
gossip.local_addr().unwrap(),
|
|
|
|
replicate.local_addr().unwrap(),
|
|
|
|
requests_socket.local_addr().unwrap(),
|
2018-05-23 07:11:11 -07:00
|
|
|
events_socket.local_addr().unwrap(),
|
2018-05-11 23:31:32 -07:00
|
|
|
);
|
|
|
|
(d, gossip, replicate, requests_socket, events_socket)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2018-05-14 14:33:11 -07:00
|
|
|
use bank::Bank;
|
2018-05-11 23:31:32 -07:00
|
|
|
use bincode::serialize;
|
|
|
|
use chrono::prelude::*;
|
|
|
|
use crdt::Crdt;
|
2018-05-16 16:49:58 -07:00
|
|
|
use entry::Entry;
|
2018-05-11 23:31:32 -07:00
|
|
|
use event::Event;
|
|
|
|
use hash::{hash, Hash};
|
|
|
|
use logger;
|
|
|
|
use mint::Mint;
|
|
|
|
use packet::BlobRecycler;
|
|
|
|
use signature::{KeyPair, KeyPairUtil};
|
|
|
|
use std::collections::VecDeque;
|
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
|
use std::sync::mpsc::channel;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
use std::time::Duration;
|
|
|
|
use streamer;
|
|
|
|
use tvu::{test_node, Tvu};
|
|
|
|
|
|
|
|
/// Test that mesasge sent from leader to target1 and repliated to target2
|
|
|
|
#[test]
|
|
|
|
fn test_replicate() {
|
|
|
|
logger::setup();
|
|
|
|
let (leader_data, leader_gossip, _, leader_serve, _) = test_node();
|
2018-05-23 07:11:11 -07:00
|
|
|
let (target1_data, target1_gossip, target1_replicate, _, target1_events) = test_node();
|
2018-05-11 23:31:32 -07:00
|
|
|
let (target2_data, target2_gossip, target2_replicate, _, _) = test_node();
|
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
|
|
|
|
//start crdt_leader
|
|
|
|
let mut crdt_l = Crdt::new(leader_data.clone());
|
|
|
|
crdt_l.set_leader(leader_data.id);
|
|
|
|
|
|
|
|
let cref_l = Arc::new(RwLock::new(crdt_l));
|
|
|
|
let t_l_gossip = Crdt::gossip(cref_l.clone(), exit.clone());
|
2018-05-12 19:00:22 -07:00
|
|
|
let window1 = streamer::default_window();
|
|
|
|
let t_l_listen = Crdt::listen(cref_l, window1, leader_gossip, exit.clone());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
//start crdt2
|
|
|
|
let mut crdt2 = Crdt::new(target2_data.clone());
|
2018-05-12 19:00:22 -07:00
|
|
|
crdt2.insert(&leader_data);
|
2018-05-11 23:31:32 -07:00
|
|
|
crdt2.set_leader(leader_data.id);
|
|
|
|
let leader_id = leader_data.id;
|
|
|
|
let cref2 = Arc::new(RwLock::new(crdt2));
|
|
|
|
let t2_gossip = Crdt::gossip(cref2.clone(), exit.clone());
|
2018-05-12 19:00:22 -07:00
|
|
|
let window2 = streamer::default_window();
|
|
|
|
let t2_listen = Crdt::listen(cref2, window2, target2_gossip, exit.clone());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
// setup some blob services to send blobs into the socket
|
|
|
|
// to simulate the source peer and get blobs out of the socket to
|
|
|
|
// simulate target peer
|
|
|
|
let recv_recycler = BlobRecycler::default();
|
|
|
|
let resp_recycler = BlobRecycler::default();
|
|
|
|
let (s_reader, r_reader) = channel();
|
|
|
|
let t_receiver = streamer::blob_receiver(
|
|
|
|
exit.clone(),
|
|
|
|
recv_recycler.clone(),
|
|
|
|
target2_replicate,
|
|
|
|
s_reader,
|
|
|
|
).unwrap();
|
|
|
|
|
|
|
|
// simulate leader sending messages
|
|
|
|
let (s_responder, r_responder) = channel();
|
|
|
|
let t_responder = streamer::responder(
|
|
|
|
leader_serve,
|
|
|
|
exit.clone(),
|
|
|
|
resp_recycler.clone(),
|
|
|
|
r_responder,
|
|
|
|
);
|
|
|
|
|
|
|
|
let starting_balance = 10_000;
|
2018-05-14 14:39:34 -07:00
|
|
|
let mint = Mint::new(starting_balance);
|
2018-05-11 23:31:32 -07:00
|
|
|
let replicate_addr = target1_data.replicate_addr;
|
2018-05-23 08:29:24 -07:00
|
|
|
let bank = Arc::new(Bank::new(&mint));
|
|
|
|
let tvu = Tvu::new(
|
|
|
|
bank,
|
2018-05-11 23:31:32 -07:00
|
|
|
target1_data,
|
|
|
|
target1_gossip,
|
2018-05-23 07:11:11 -07:00
|
|
|
target1_events,
|
2018-05-11 23:31:32 -07:00
|
|
|
target1_replicate,
|
|
|
|
leader_data,
|
|
|
|
exit.clone(),
|
2018-05-23 08:29:24 -07:00
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
let mut alice_ref_balance = starting_balance;
|
|
|
|
let mut msgs = VecDeque::new();
|
|
|
|
let mut cur_hash = Hash::default();
|
|
|
|
let num_blobs = 10;
|
|
|
|
let transfer_amount = 501;
|
|
|
|
let bob_keypair = KeyPair::new();
|
|
|
|
for i in 0..num_blobs {
|
|
|
|
let b = resp_recycler.allocate();
|
|
|
|
let b_ = b.clone();
|
|
|
|
let mut w = b.write().unwrap();
|
|
|
|
w.set_index(i).unwrap();
|
|
|
|
w.set_id(leader_id).unwrap();
|
|
|
|
|
|
|
|
let tr0 = Event::new_timestamp(&bob_keypair, Utc::now());
|
2018-05-16 16:49:58 -07:00
|
|
|
let entry0 = Entry::new(&cur_hash, i, vec![tr0]);
|
2018-05-14 14:33:11 -07:00
|
|
|
bank.register_entry_id(&cur_hash);
|
2018-05-11 23:31:32 -07:00
|
|
|
cur_hash = hash(&cur_hash);
|
|
|
|
|
2018-05-16 16:35:21 -07:00
|
|
|
let tr1 = Event::new_transaction(
|
2018-05-14 14:39:34 -07:00
|
|
|
&mint.keypair(),
|
2018-05-11 23:31:32 -07:00
|
|
|
bob_keypair.pubkey(),
|
|
|
|
transfer_amount,
|
|
|
|
cur_hash,
|
|
|
|
);
|
2018-05-14 14:33:11 -07:00
|
|
|
bank.register_entry_id(&cur_hash);
|
2018-05-11 23:31:32 -07:00
|
|
|
cur_hash = hash(&cur_hash);
|
2018-05-16 16:49:58 -07:00
|
|
|
let entry1 = Entry::new(&cur_hash, i + num_blobs, vec![tr1]);
|
2018-05-14 14:33:11 -07:00
|
|
|
bank.register_entry_id(&cur_hash);
|
2018-05-11 23:31:32 -07:00
|
|
|
cur_hash = hash(&cur_hash);
|
|
|
|
|
|
|
|
alice_ref_balance -= transfer_amount;
|
|
|
|
|
|
|
|
let serialized_entry = serialize(&vec![entry0, entry1]).unwrap();
|
|
|
|
|
|
|
|
w.data_mut()[..serialized_entry.len()].copy_from_slice(&serialized_entry);
|
|
|
|
w.set_size(serialized_entry.len());
|
|
|
|
w.meta.set_addr(&replicate_addr);
|
|
|
|
drop(w);
|
|
|
|
msgs.push_back(b_);
|
|
|
|
}
|
|
|
|
|
|
|
|
// send the blobs into the socket
|
|
|
|
s_responder.send(msgs).expect("send");
|
|
|
|
|
|
|
|
// receive retransmitted messages
|
|
|
|
let timer = Duration::new(1, 0);
|
|
|
|
let mut msgs: Vec<_> = Vec::new();
|
|
|
|
while let Ok(msg) = r_reader.recv_timeout(timer) {
|
|
|
|
trace!("msg: {:?}", msg);
|
|
|
|
msgs.push(msg);
|
|
|
|
}
|
|
|
|
|
2018-05-14 14:39:34 -07:00
|
|
|
let alice_balance = bank.get_balance(&mint.keypair().pubkey()).unwrap();
|
2018-05-11 23:31:32 -07:00
|
|
|
assert_eq!(alice_balance, alice_ref_balance);
|
|
|
|
|
2018-05-14 14:33:11 -07:00
|
|
|
let bob_balance = bank.get_balance(&bob_keypair.pubkey()).unwrap();
|
2018-05-11 23:31:32 -07:00
|
|
|
assert_eq!(bob_balance, starting_balance - alice_ref_balance);
|
|
|
|
|
|
|
|
exit.store(true, Ordering::Relaxed);
|
2018-05-23 08:29:24 -07:00
|
|
|
for t in tvu.thread_hdls {
|
2018-05-11 23:31:32 -07:00
|
|
|
t.join().expect("join");
|
|
|
|
}
|
|
|
|
t2_gossip.join().expect("join");
|
|
|
|
t2_listen.join().expect("join");
|
|
|
|
t_receiver.join().expect("join");
|
|
|
|
t_responder.join().expect("join");
|
|
|
|
t_l_gossip.join().expect("join");
|
|
|
|
t_l_listen.join().expect("join");
|
|
|
|
}
|
|
|
|
}
|