2018-05-11 23:31:32 -07:00
|
|
|
//! The `tvu` module implements the Transaction Validation Unit, a
|
2018-06-14 17:05:12 -07:00
|
|
|
//! 3-stage transaction validation pipeline in software.
|
|
|
|
//!
|
|
|
|
//! ```text
|
2018-08-09 12:03:34 -07:00
|
|
|
//! .------------------------------------------------.
|
|
|
|
//! | |
|
|
|
|
//! | .------------------------------------+------------.
|
|
|
|
//! | | TVU | |
|
|
|
|
//! | | | |
|
|
|
|
//! | | | | .------------.
|
|
|
|
//! | | .----------------+-------------->| Validators |
|
|
|
|
//! v | .-------. | | | `------------`
|
|
|
|
//! .----+---. | | | .----+-------. .----+---------. |
|
|
|
|
//! | Leader |--------->| Blob | | Retransmit | | Replicate | |
|
|
|
|
//! `--------` | | Fetch |-->| Stage |-->| Stage / | |
|
|
|
|
//! .------------. | | Stage | | | | Vote Stage | |
|
|
|
|
//! | Validators |----->| | `------------` `----+---------` |
|
|
|
|
//! `------------` | `-------` | |
|
|
|
|
//! | | |
|
|
|
|
//! | | |
|
|
|
|
//! | | |
|
|
|
|
//! `------------------------------------|------------`
|
|
|
|
//! |
|
|
|
|
//! v
|
|
|
|
//! .------.
|
|
|
|
//! | Bank |
|
|
|
|
//! `------`
|
2018-06-14 17:05:12 -07:00
|
|
|
//! ```
|
2018-06-15 14:49:22 -07:00
|
|
|
//!
|
|
|
|
//! 1. Fetch Stage
|
|
|
|
//! - Incoming blobs are picked up from the replicate socket and repair socket.
|
2018-07-30 16:56:01 -07:00
|
|
|
//! 2. SharedWindow Stage
|
2018-06-15 14:49:22 -07:00
|
|
|
//! - Blobs are windowed until a contiguous chunk is available. This stage also repairs and
|
|
|
|
//! retransmits blobs that are in the queue.
|
|
|
|
//! 3. Replicate Stage
|
|
|
|
//! - Transactions in blobs are processed and applied to the bank.
|
|
|
|
//! - TODO We need to verify the signatures in the blobs.
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-05-14 14:33:11 -07:00
|
|
|
use bank::Bank;
|
2018-06-13 21:52:23 -07:00
|
|
|
use blob_fetch_stage::BlobFetchStage;
|
|
|
|
use crdt::Crdt;
|
2018-06-27 11:33:56 -07:00
|
|
|
use packet::BlobRecycler;
|
2018-05-22 15:17:59 -07:00
|
|
|
use replicate_stage::ReplicateStage;
|
2018-08-09 12:03:34 -07:00
|
|
|
use retransmit_stage::RetransmitStage;
|
2018-07-03 21:14:08 -07:00
|
|
|
use service::Service;
|
2018-08-09 07:56:04 -07:00
|
|
|
use signature::Keypair;
|
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-11 23:31:32 -07:00
|
|
|
use std::sync::{Arc, RwLock};
|
2018-07-03 21:14:08 -07:00
|
|
|
use std::thread::{self, JoinHandle};
|
2018-08-09 12:31:34 -07:00
|
|
|
use window::SharedWindow;
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
pub struct Tvu {
|
2018-07-03 21:14:08 -07:00
|
|
|
replicate_stage: ReplicateStage,
|
|
|
|
fetch_stage: BlobFetchStage,
|
2018-08-09 12:03:34 -07:00
|
|
|
retransmit_stage: RetransmitStage,
|
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-06-27 12:35:58 -07:00
|
|
|
/// * `entry_height` - Initial ledger height, passed to replicate stage
|
2018-06-13 21:52:23 -07:00
|
|
|
/// * `crdt` - The crdt state.
|
|
|
|
/// * `window` - The window state.
|
|
|
|
/// * `replicate_socket` - my replicate socket
|
|
|
|
/// * `repair_socket` - my repair socket
|
|
|
|
/// * `retransmit_socket` - my retransmit socket
|
2018-05-11 23:31:32 -07:00
|
|
|
/// * `exit` - The exit signal.
|
2018-08-03 11:06:06 -07:00
|
|
|
#[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
|
2018-05-23 07:11:11 -07:00
|
|
|
pub fn new(
|
2018-08-09 07:56:04 -07:00
|
|
|
keypair: Keypair,
|
2018-07-13 12:32:20 -07:00
|
|
|
bank: &Arc<Bank>,
|
2018-06-27 12:35:58 -07:00
|
|
|
entry_height: u64,
|
2018-06-13 21:52:23 -07:00
|
|
|
crdt: Arc<RwLock<Crdt>>,
|
2018-07-30 16:56:01 -07:00
|
|
|
window: SharedWindow,
|
2018-06-13 21:52:23 -07:00
|
|
|
replicate_socket: UdpSocket,
|
2018-06-02 08:32:51 -07:00
|
|
|
repair_socket: UdpSocket,
|
2018-06-13 21:52:23 -07:00
|
|
|
retransmit_socket: UdpSocket,
|
2018-08-05 22:04:27 -07:00
|
|
|
ledger_path: Option<&str>,
|
2018-05-11 23:31:32 -07:00
|
|
|
exit: Arc<AtomicBool>,
|
2018-05-23 07:11:11 -07:00
|
|
|
) -> Self {
|
2018-08-30 12:07:54 -07:00
|
|
|
let repair_socket = Arc::new(repair_socket);
|
2018-06-27 11:33:56 -07:00
|
|
|
let blob_recycler = BlobRecycler::default();
|
2018-07-05 12:01:40 -07:00
|
|
|
let (fetch_stage, blob_fetch_receiver) = BlobFetchStage::new_multi_socket(
|
2018-08-30 12:07:54 -07:00
|
|
|
vec![Arc::new(replicate_socket), repair_socket.clone()],
|
2018-07-19 21:27:35 -07:00
|
|
|
exit.clone(),
|
2018-07-13 12:32:20 -07:00
|
|
|
&blob_recycler,
|
2018-05-11 23:31:32 -07:00
|
|
|
);
|
|
|
|
//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
|
2018-08-09 12:03:34 -07:00
|
|
|
let (retransmit_stage, blob_window_receiver) = RetransmitStage::new(
|
2018-07-13 12:32:20 -07:00
|
|
|
&crdt,
|
2018-05-12 19:00:22 -07:00
|
|
|
window,
|
2018-06-27 12:35:58 -07:00
|
|
|
entry_height,
|
2018-08-28 16:32:40 -07:00
|
|
|
Arc::new(retransmit_socket),
|
2018-08-30 12:07:54 -07:00
|
|
|
repair_socket,
|
2018-07-13 12:32:20 -07:00
|
|
|
&blob_recycler,
|
2018-07-05 12:01:40 -07:00
|
|
|
blob_fetch_receiver,
|
2018-05-22 15:17:59 -07:00
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-07-13 12:32:20 -07:00
|
|
|
let replicate_stage = ReplicateStage::new(
|
|
|
|
keypair,
|
|
|
|
bank.clone(),
|
|
|
|
crdt,
|
|
|
|
blob_recycler,
|
|
|
|
blob_window_receiver,
|
2018-08-03 11:06:06 -07:00
|
|
|
ledger_path,
|
2018-07-19 21:27:35 -07:00
|
|
|
exit,
|
2018-07-13 12:32:20 -07:00
|
|
|
);
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2018-05-23 10:54:48 -07:00
|
|
|
Tvu {
|
2018-07-03 21:14:08 -07:00
|
|
|
replicate_stage,
|
|
|
|
fetch_stage,
|
2018-08-09 12:03:34 -07:00
|
|
|
retransmit_stage,
|
2018-05-23 10:54:48 -07:00
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
2018-07-09 13:53:18 -07:00
|
|
|
|
|
|
|
pub fn close(self) -> thread::Result<()> {
|
|
|
|
self.fetch_stage.close();
|
|
|
|
self.join()
|
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
2018-07-03 21:14:08 -07:00
|
|
|
impl Service for Tvu {
|
|
|
|
fn thread_hdls(self) -> Vec<JoinHandle<()>> {
|
|
|
|
let mut thread_hdls = vec![];
|
|
|
|
thread_hdls.extend(self.replicate_stage.thread_hdls().into_iter());
|
|
|
|
thread_hdls.extend(self.fetch_stage.thread_hdls().into_iter());
|
2018-08-09 12:03:34 -07:00
|
|
|
thread_hdls.extend(self.retransmit_stage.thread_hdls().into_iter());
|
2018-07-03 21:14:08 -07:00
|
|
|
thread_hdls
|
|
|
|
}
|
|
|
|
|
|
|
|
fn join(self) -> thread::Result<()> {
|
|
|
|
for thread_hdl in self.thread_hdls() {
|
|
|
|
thread_hdl.join()?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-11 23:31:32 -07:00
|
|
|
#[cfg(test)]
|
2018-05-23 10:49:48 -07:00
|
|
|
pub mod tests {
|
2018-05-14 14:33:11 -07:00
|
|
|
use bank::Bank;
|
2018-05-11 23:31:32 -07:00
|
|
|
use bincode::serialize;
|
2018-08-28 16:32:40 -07:00
|
|
|
use crdt::{Crdt, Node};
|
2018-05-16 16:49:58 -07:00
|
|
|
use entry::Entry;
|
2018-05-11 23:31:32 -07:00
|
|
|
use hash::{hash, Hash};
|
|
|
|
use logger;
|
|
|
|
use mint::Mint;
|
2018-06-07 15:06:32 -07:00
|
|
|
use ncp::Ncp;
|
2018-05-11 23:31:32 -07:00
|
|
|
use packet::BlobRecycler;
|
2018-07-03 21:14:08 -07:00
|
|
|
use service::Service;
|
2018-08-09 07:56:04 -07:00
|
|
|
use signature::{Keypair, KeypairUtil};
|
2018-05-27 18:21:39 -07:00
|
|
|
use std::net::UdpSocket;
|
2018-07-09 13:53:18 -07:00
|
|
|
use std::sync::atomic::AtomicBool;
|
2018-05-11 23:31:32 -07:00
|
|
|
use std::sync::mpsc::channel;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
use std::time::Duration;
|
2018-08-09 12:31:34 -07:00
|
|
|
use streamer;
|
2018-05-23 23:29:01 -07:00
|
|
|
use transaction::Transaction;
|
2018-05-27 18:21:39 -07:00
|
|
|
use tvu::Tvu;
|
2018-08-09 12:31:34 -07:00
|
|
|
use window::{self, SharedWindow};
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-06-13 21:52:23 -07:00
|
|
|
fn new_ncp(
|
2018-05-27 18:21:39 -07:00
|
|
|
crdt: Arc<RwLock<Crdt>>,
|
2018-08-28 16:32:40 -07:00
|
|
|
gossip: UdpSocket,
|
2018-05-27 18:21:39 -07:00
|
|
|
exit: Arc<AtomicBool>,
|
2018-09-03 02:23:43 -07:00
|
|
|
) -> (Ncp, SharedWindow) {
|
2018-08-09 12:31:34 -07:00
|
|
|
let window = window::default_window();
|
2018-09-03 02:23:43 -07:00
|
|
|
let ncp = Ncp::new(&crdt, window.clone(), None, gossip, exit);
|
|
|
|
(ncp, window)
|
2018-05-27 18:21:39 -07:00
|
|
|
}
|
2018-08-03 11:06:06 -07:00
|
|
|
|
2018-05-25 23:24:29 -07:00
|
|
|
/// Test that message sent from leader to target1 and replicated to target2
|
2018-05-11 23:31:32 -07:00
|
|
|
#[test]
|
|
|
|
fn test_replicate() {
|
|
|
|
logger::setup();
|
2018-08-28 16:32:40 -07:00
|
|
|
let leader = Node::new_localhost();
|
2018-08-09 07:56:04 -07:00
|
|
|
let target1_keypair = Keypair::new();
|
2018-08-28 16:32:40 -07:00
|
|
|
let target1 = Node::new_localhost_with_pubkey(target1_keypair.pubkey());
|
|
|
|
let target2 = Node::new_localhost();
|
2018-05-11 23:31:32 -07:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
|
|
|
|
//start crdt_leader
|
2018-08-31 00:10:39 -07:00
|
|
|
let mut crdt_l = Crdt::new(leader.info.clone()).expect("Crdt::new");
|
|
|
|
crdt_l.set_leader(leader.info.id);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
let cref_l = Arc::new(RwLock::new(crdt_l));
|
2018-09-03 02:23:43 -07:00
|
|
|
let dr_l = new_ncp(cref_l, leader.sockets.gossip, exit.clone());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
//start crdt2
|
2018-08-31 00:10:39 -07:00
|
|
|
let mut crdt2 = Crdt::new(target2.info.clone()).expect("Crdt::new");
|
|
|
|
crdt2.insert(&leader.info);
|
|
|
|
crdt2.set_leader(leader.info.id);
|
|
|
|
let leader_id = leader.info.id;
|
2018-05-11 23:31:32 -07:00
|
|
|
let cref2 = Arc::new(RwLock::new(crdt2));
|
2018-09-03 02:23:43 -07:00
|
|
|
let dr_2 = new_ncp(cref2, target2.sockets.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(
|
2018-08-28 16:32:40 -07:00
|
|
|
Arc::new(target2.sockets.replicate),
|
2018-05-11 23:31:32 -07:00
|
|
|
exit.clone(),
|
|
|
|
recv_recycler.clone(),
|
|
|
|
s_reader,
|
2018-09-03 02:23:43 -07:00
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
// simulate leader sending messages
|
|
|
|
let (s_responder, r_responder) = channel();
|
2018-07-11 07:38:57 -07:00
|
|
|
let t_responder = streamer::responder(
|
|
|
|
"test_replicate",
|
2018-08-28 16:32:40 -07:00
|
|
|
Arc::new(leader.sockets.requests),
|
2018-07-11 07:38:57 -07:00
|
|
|
resp_recycler.clone(),
|
|
|
|
r_responder,
|
|
|
|
);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
let starting_balance = 10_000;
|
2018-05-14 14:39:34 -07:00
|
|
|
let mint = Mint::new(starting_balance);
|
2018-08-31 00:10:39 -07:00
|
|
|
let replicate_addr = target1.info.contact_info.tvu;
|
2018-05-23 08:29:24 -07:00
|
|
|
let bank = Arc::new(Bank::new(&mint));
|
2018-06-13 21:52:23 -07:00
|
|
|
|
|
|
|
//start crdt1
|
2018-08-31 00:10:39 -07:00
|
|
|
let mut crdt1 = Crdt::new(target1.info.clone()).expect("Crdt::new");
|
|
|
|
crdt1.insert(&leader.info);
|
|
|
|
crdt1.set_leader(leader.info.id);
|
2018-06-13 21:52:23 -07:00
|
|
|
let cref1 = Arc::new(RwLock::new(crdt1));
|
2018-09-03 02:23:43 -07:00
|
|
|
let dr_1 = new_ncp(cref1.clone(), target1.sockets.gossip, exit.clone());
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2018-05-23 08:29:24 -07:00
|
|
|
let tvu = Tvu::new(
|
2018-07-31 22:07:53 -07:00
|
|
|
target1_keypair,
|
2018-07-13 12:32:20 -07:00
|
|
|
&bank,
|
2018-06-27 12:35:58 -07:00
|
|
|
0,
|
2018-06-13 21:52:23 -07:00
|
|
|
cref1,
|
|
|
|
dr_1.1,
|
2018-05-23 11:06:18 -07:00
|
|
|
target1.sockets.replicate,
|
2018-06-02 08:32:51 -07:00
|
|
|
target1.sockets.repair,
|
2018-06-13 21:52:23 -07:00
|
|
|
target1.sockets.retransmit,
|
2018-08-05 22:04:27 -07:00
|
|
|
None,
|
2018-05-11 23:31:32 -07:00
|
|
|
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;
|
2018-09-03 03:22:47 -07:00
|
|
|
let mut msgs = Vec::new();
|
2018-05-11 23:31:32 -07:00
|
|
|
let mut cur_hash = Hash::default();
|
2018-06-20 11:40:41 -07:00
|
|
|
let mut blob_id = 0;
|
|
|
|
let num_transfers = 10;
|
2018-05-11 23:31:32 -07:00
|
|
|
let transfer_amount = 501;
|
2018-08-09 07:56:04 -07:00
|
|
|
let bob_keypair = Keypair::new();
|
2018-06-20 11:40:41 -07:00
|
|
|
for i in 0..num_transfers {
|
2018-06-25 23:28:41 -07:00
|
|
|
let entry0 = Entry::new(&cur_hash, i, vec![], false);
|
2018-05-14 14:33:11 -07:00
|
|
|
bank.register_entry_id(&cur_hash);
|
2018-08-01 11:23:52 -07:00
|
|
|
cur_hash = hash(&cur_hash.as_ref());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
2018-05-29 09:12:27 -07:00
|
|
|
let tx0 = Transaction::new(
|
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-08-01 11:23:52 -07:00
|
|
|
cur_hash = hash(&cur_hash.as_ref());
|
2018-06-25 23:28:41 -07:00
|
|
|
let entry1 = Entry::new(&cur_hash, i + num_transfers, vec![tx0], false);
|
2018-05-14 14:33:11 -07:00
|
|
|
bank.register_entry_id(&cur_hash);
|
2018-08-01 11:23:52 -07:00
|
|
|
cur_hash = hash(&cur_hash.as_ref());
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
alice_ref_balance -= transfer_amount;
|
|
|
|
|
2018-06-20 11:40:41 -07:00
|
|
|
for entry in vec![entry0, entry1] {
|
|
|
|
let b = resp_recycler.allocate();
|
2018-06-25 17:16:32 -07:00
|
|
|
{
|
|
|
|
let mut w = b.write().unwrap();
|
|
|
|
w.set_index(blob_id).unwrap();
|
|
|
|
blob_id += 1;
|
|
|
|
w.set_id(leader_id).unwrap();
|
|
|
|
|
|
|
|
let serialized_entry = serialize(&entry).unwrap();
|
|
|
|
|
|
|
|
w.data_mut()[..serialized_entry.len()].copy_from_slice(&serialized_entry);
|
|
|
|
w.set_size(serialized_entry.len());
|
|
|
|
w.meta.set_addr(&replicate_addr);
|
|
|
|
}
|
2018-09-03 03:22:47 -07:00
|
|
|
msgs.push(b);
|
2018-06-20 11:40:41 -07:00
|
|
|
}
|
2018-05-11 23:31:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// send the blobs into the socket
|
|
|
|
s_responder.send(msgs).expect("send");
|
2018-07-05 15:41:03 -07:00
|
|
|
drop(s_responder);
|
2018-05-11 23:31:32 -07:00
|
|
|
|
|
|
|
// receive retransmitted messages
|
|
|
|
let timer = Duration::new(1, 0);
|
|
|
|
while let Ok(msg) = r_reader.recv_timeout(timer) {
|
|
|
|
trace!("msg: {:?}", msg);
|
|
|
|
}
|
|
|
|
|
2018-07-02 16:31:10 -07:00
|
|
|
let alice_balance = bank.get_balance(&mint.keypair().pubkey());
|
2018-05-11 23:31:32 -07:00
|
|
|
assert_eq!(alice_balance, alice_ref_balance);
|
|
|
|
|
2018-07-02 16:31:10 -07:00
|
|
|
let bob_balance = bank.get_balance(&bob_keypair.pubkey());
|
2018-05-11 23:31:32 -07:00
|
|
|
assert_eq!(bob_balance, starting_balance - alice_ref_balance);
|
|
|
|
|
2018-07-09 13:53:18 -07:00
|
|
|
tvu.close().expect("close");
|
2018-07-03 21:14:08 -07:00
|
|
|
dr_l.0.join().expect("join");
|
|
|
|
dr_2.0.join().expect("join");
|
|
|
|
dr_1.0.join().expect("join");
|
2018-05-11 23:31:32 -07:00
|
|
|
t_receiver.join().expect("join");
|
|
|
|
t_responder.join().expect("join");
|
|
|
|
}
|
|
|
|
}
|