blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

initial vote stage 

wip

voting

wip

move voting into the replicate stage

update

fixup!

fixup!

fixup!

fixup!

fixup!

fixup!

fixup!

fixup!

fixup!

fixup!

update

fixup!

fixup!

fixup!

tpu processing votes in entries before write stage

fixup!

fixup!

txs

make sure validators have an account

fixup!

fixup!

fixup!

exit fullnode correctly

exit on exit not err

try 50

add delay for voting

300

300

startup logs

par start

100

no rayon

retry longer

log leader drop

fix distance

50 nodes

100

handle deserialize error

update

fix broadcast

new table every time

tweaks

table

update

try shuffle table

skip kill

skip add

purge test

fixed tests

rebase 2

fixed tests

fixed rebase

cleanup

ok for blobs to be longer then window

fix init window

60 nodes
This commit is contained in:
Anatoly Yakovenko 2018-07-05 12:01:40 -07:00 committed by Greg Fitzgerald
parent 0672794692
commit be2bf69c93
19 changed files with 479 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/bank.rs
View File

@ -249,6 +249,10 @@ impl Bank {
Instruction::ApplySignature(tx_sig) => {
let _ = self.apply_signature(tx.from, *tx_sig);
}
Instruction::NewVote(_vote) => {
info!("GOT VOTE!");
// TODO: record the vote in the stake table...
}
}
}

5
src/bin/client-demo.rs
View File

@ -10,6 +10,7 @@ use clap::{App, Arg};
use rayon::prelude::*;
use solana::crdt::{Crdt, ReplicatedData};
use solana::drone::DroneRequest;
use solana::fullnode::Config;
use solana::hash::Hash;
use solana::mint::Mint;
use solana::nat::{udp_public_bind, udp_random_bind};
@ -186,7 +187,7 @@ fn main() {
let leader: ReplicatedData;
if let Some(l) = matches.value_of("leader") {
leader = read_leader(l.to_string());
leader = read_leader(l.to_string()).network;
} else {
let server_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8000);
leader = ReplicatedData::new_leader(&server_addr);
@ -395,7 +396,7 @@ fn converge(
rv
}
fn read_leader(path: String) -> ReplicatedData {
fn read_leader(path: String) -> Config {
let file = File::open(path.clone()).expect(&format!("file not found: {}", path));
serde_json::from_reader(file).expect(&format!("failed to parse {}", path))
}

5
src/bin/drone.rs
View File

@ -11,6 +11,7 @@ use bincode::deserialize;
use clap::{App, Arg};
use solana::crdt::ReplicatedData;
use solana::drone::{Drone, DroneRequest};
use solana::fullnode::Config;
use solana::mint::Mint;
use std::error;
use std::fs::File;
@ -61,7 +62,7 @@ fn main() {
let leader: ReplicatedData;
if let Some(l) = matches.value_of("leader") {
leader = read_leader(l.to_string());
leader = read_leader(l.to_string()).network;
} else {
let server_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8000);
leader = ReplicatedData::new_leader(&server_addr);
@ -147,7 +148,7 @@ fn main() {
});
tokio::run(done);
}
fn read_leader(path: String) -> ReplicatedData {
fn read_leader(path: String) -> Config {
let file = File::open(path.clone()).expect(&format!("file not found: {}", path));
serde_json::from_reader(file).expect(&format!("failed to parse {}", path))
}

7
src/bin/fullnode-config.rs
View File

@ -3,7 +3,8 @@ extern crate serde_json;
extern crate solana;
use clap::{App, Arg};
use solana::crdt::{get_ip_addr, parse_port_or_addr, ReplicatedData};
use solana::crdt::{get_ip_addr, parse_port_or_addr};
use solana::fullnode::Config;
use solana::nat::get_public_ip_addr;
use std::io;
use std::net::SocketAddr;
@ -55,7 +56,7 @@ fn main() {
// we need all the receiving sockets to be bound within the expected
// port range that we open on aws
let repl_data = ReplicatedData::new_leader(&bind_addr);
let config = Config::new(&bind_addr);
let stdout = io::stdout();
serde_json::to_writer(stdout, &repl_data).expect("serialize");
serde_json::to_writer(stdout, &config).expect("serialize");
}

23
src/bin/fullnode.rs
View File

@ -9,8 +9,9 @@ extern crate solana;
use atty::{is, Stream};
use clap::{App, Arg};
use solana::crdt::{ReplicatedData, TestNode};
use solana::fullnode::{FullNode, InFile, OutFile};
use solana::fullnode::{Config, FullNode, InFile, OutFile};
use solana::service::Service;
use solana::signature::{KeyPair, KeyPairUtil};
use std::fs::File;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::process::exit;
@ -50,12 +51,15 @@ fn main() -> () {
}
let bind_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8000);
let mut repl_data = ReplicatedData::new_leader(&bind_addr);
let mut keypair = KeyPair::new();
let mut repl_data = ReplicatedData::new_leader_with_pubkey(keypair.pubkey(), &bind_addr);
if let Some(l) = matches.value_of("identity") {
let path = l.to_string();
if let Ok(file) = File::open(path.clone()) {
if let Ok(data) = serde_json::from_reader(file) {
repl_data = data;
let parse: serde_json::Result<Config> = serde_json::from_reader(file);
if let Ok(data) = parse {
keypair = data.keypair();
repl_data = data.network;
} else {
eprintln!("failed to parse {}", path);
exit(1);
@ -69,7 +73,7 @@ fn main() -> () {
let fullnode = if let Some(t) = matches.value_of("testnet") {
let testnet_address_string = t.to_string();
let testnet_addr = testnet_address_string.parse().unwrap();
FullNode::new(node, false, InFile::StdIn, Some(testnet_addr), None)
FullNode::new(node, false, InFile::StdIn, None, Some(testnet_addr), None)
} else {
node.data.current_leader_id = node.data.id.clone();
@ -78,7 +82,14 @@ fn main() -> () {
} else {
OutFile::StdOut
};
FullNode::new(node, true, InFile::StdIn, None, Some(outfile))
FullNode::new(
node,
true,
InFile::StdIn,
Some(keypair),
None,
Some(outfile),
)
};
fullnode.join().expect("join");
}

5
src/bin/wallet.rs
View File

@ -10,6 +10,7 @@ use bincode::serialize;
use clap::{App, Arg, SubCommand};
use solana::crdt::ReplicatedData;
use solana::drone::DroneRequest;
use solana::fullnode::Config;
use solana::mint::Mint;
use solana::signature::{PublicKey, Signature};
use solana::thin_client::ThinClient;
@ -142,7 +143,7 @@ fn parse_args() -> Result<WalletConfig, Box<error::Error>> {
let leader: ReplicatedData;
if let Some(l) = matches.value_of("leader") {
leader = read_leader(l.to_string());
leader = read_leader(l.to_string()).network;
} else {
let server_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8000);
leader = ReplicatedData::new_leader(&server_addr);
@ -286,7 +287,7 @@ fn display_actions() {
println!("");
}
fn read_leader(path: String) -> ReplicatedData {
fn read_leader(path: String) -> Config {
let file = File::open(path.clone()).expect(&format!("file not found: {}", path));
serde_json::from_reader(file).expect(&format!("failed to parse {}", path))
}

158
src/crdt.rs
View File

@ -34,6 +34,7 @@ use std::thread::{sleep, Builder, JoinHandle};
use std::time::Duration;
use streamer::{BlobReceiver, BlobSender, Window};
use timing::timestamp;
use transaction::Vote;
/// milliseconds we sleep for between gossip requests
const GOSSIP_SLEEP_MILLIS: u64 = 100;
@ -286,6 +287,63 @@ impl Crdt {
self.external_liveness.get(key)
}
pub fn insert_vote(&mut self, pubkey: &PublicKey, v: &Vote, last_id: Hash) {
if self.table.get(pubkey).is_none() {
warn!(
"{:x}: VOTE for unknown id: {:x}",
self.debug_id(),
make_debug_id(&pubkey)
);
return;
}
if v.contact_info_version > self.table[pubkey].contact_info.version {
warn!(
"{:x}: VOTE for new address version from: {:x} ours: {} vote: {:?}",
self.debug_id(),
make_debug_id(pubkey),
self.table[pubkey].contact_info.version,
v,
);
return;
}
self.update_leader_liveness();
if v.version <= self.table[pubkey].version {
debug!(
"{:x}: VOTE for old version: {:x}",
self.debug_id(),
make_debug_id(&pubkey)
);
self.update_liveness(*pubkey);
return;
} else {
let mut data = self.table[pubkey].clone();
data.version = v.version;
data.last_verified_id = last_id;
debug!(
"{:x}: INSERTING VOTE! for {:x}",
self.debug_id(),
data.debug_id()
);
self.insert(&data);
}
}
fn update_leader_liveness(&mut self) {
//TODO: (leaders should vote)
//until then we pet their liveness every time we see some votes from anyone
let ld = self.leader_data().map(|x| x.id.clone());
trace!("leader_id {:?}", ld);
if let Some(leader_id) = ld {
self.update_liveness(leader_id);
}
}
pub fn insert_votes(&mut self, votes: Vec<(PublicKey, Vote, Hash)>) {
if votes.len() > 0 {
info!("{:x}: INSERTING VOTES {}", self.debug_id(), votes.len());
}
for v in &votes {
self.insert_vote(&v.0, &v.1, v.2);
}
}
pub fn insert(&mut self, v: &ReplicatedData) {
// TODO check that last_verified types are always increasing
//update the peer table
@ -643,6 +701,20 @@ impl Crdt {
Ok((v.contact_info.ncp, req))
}
pub fn new_vote(&mut self, height: u64, last_id: Hash) -> Result<(Vote, SocketAddr)> {
let mut me = self.my_data().clone();
let leader = self.leader_data().ok_or(CrdtError::NoLeader)?.clone();
me.version += 1;
me.last_verified_id = last_id;
me.last_verified_height = height;
let vote = Vote {
version: me.version,
contact_info_version: me.contact_info.version,
};
self.insert(&me);
Ok((vote, leader.contact_info.tpu))
}
/// At random pick a node and try to get updated changes from them
fn run_gossip(
obj: &Arc<RwLock<Self>>,
@ -1080,6 +1152,7 @@ mod tests {
parse_port_or_addr, Crdt, CrdtError, ReplicatedData, GOSSIP_PURGE_MILLIS,
GOSSIP_SLEEP_MILLIS, MIN_TABLE_SIZE,
};
use hash::Hash;
use logger;
use packet::BlobRecycler;
use result::Error;
@ -1090,6 +1163,7 @@ mod tests {
use std::thread::sleep;
use std::time::Duration;
use streamer::default_window;
use transaction::Vote;
#[test]
fn test_parse_port_or_addr() {
@ -1120,6 +1194,90 @@ mod tests {
crdt.insert(&d);
assert_eq!(crdt.table[&d.id].version, 2);
}
#[test]
fn test_new_vote() {
let d = ReplicatedData::new_leader(&"127.0.0.1:1234".parse().unwrap());
assert_eq!(d.version, 0);
let mut crdt = Crdt::new(d.clone());
assert_eq!(crdt.table[&d.id].version, 0);
let leader = ReplicatedData::new_leader(&"127.0.0.2:1235".parse().unwrap());
assert_ne!(d.id, leader.id);
assert_matches!(
crdt.new_vote(0, Hash::default()).err(),
Some(Error::CrdtError(CrdtError::NoLeader))
);
crdt.insert(&leader);
assert_matches!(
crdt.new_vote(0, Hash::default()).err(),
Some(Error::CrdtError(CrdtError::NoLeader))
);
crdt.set_leader(leader.id);
assert_eq!(crdt.table[&d.id].version, 1);
let v = Vote {
version: 2, //version shoud increase when we vote
contact_info_version: 0,
};
let expected = (v, crdt.table[&leader.id].contact_info.tpu);
assert_eq!(crdt.new_vote(0, Hash::default()).unwrap(), expected);
}
#[test]
fn test_insert_vote() {
let d = ReplicatedData::new_leader(&"127.0.0.1:1234".parse().unwrap());
assert_eq!(d.version, 0);
let mut crdt = Crdt::new(d.clone());
assert_eq!(crdt.table[&d.id].version, 0);
let vote_same_version = Vote {
version: d.version,
contact_info_version: 0,
};
crdt.insert_vote(&d.id, &vote_same_version, Hash::default());
assert_eq!(crdt.table[&d.id].version, 0);
let vote_new_version_new_addrs = Vote {
version: d.version + 1,
contact_info_version: 1,
};
crdt.insert_vote(&d.id, &vote_new_version_new_addrs, Hash::default());
//should be dropped since the address is newer then we know
assert_eq!(crdt.table[&d.id].version, 0);
let vote_new_version_old_addrs = Vote {
version: d.version + 1,
contact_info_version: 0,
};
crdt.insert_vote(&d.id, &vote_new_version_old_addrs, Hash::default());
//should be accepted, since the update is for the same address field as the one we know
assert_eq!(crdt.table[&d.id].version, 1);
}
#[test]
fn test_insert_vote_leader_liveness() {
logger::setup();
// TODO: remove this test once leaders vote
let d = ReplicatedData::new_leader(&"127.0.0.1:1234".parse().unwrap());
assert_eq!(d.version, 0);
let mut crdt = Crdt::new(d.clone());
let leader = ReplicatedData::new_leader(&"127.0.0.2:1235".parse().unwrap());
assert_ne!(d.id, leader.id);
crdt.insert(&leader);
crdt.set_leader(leader.id);
let live: u64 = crdt.alive[&leader.id];
trace!("{:x} live {}", leader.debug_id(), live);
let vote_new_version_old_addrs = Vote {
version: d.version + 1,
contact_info_version: 0,
};
sleep(Duration::from_millis(100));
let votes = vec![(d.id.clone(), vote_new_version_old_addrs, Hash::default())];
crdt.insert_votes(votes);
let updated = crdt.alive[&leader.id];
//should be accepted, since the update is for the same address field as the one we know
assert_eq!(crdt.table[&d.id].version, 1);
trace!("{:x} {} {}", leader.debug_id(), updated, live);
assert!(updated > live);
}
fn sorted(ls: &Vec<ReplicatedData>) -> Vec<ReplicatedData> {
let mut copy: Vec<_> = ls.iter().cloned().collect();
copy.sort_by(|x, y| x.id.cmp(&y.id));

48
src/fullnode.rs
View File

@ -7,8 +7,10 @@ use entry_writer;
use ledger::Block;
use ncp::Ncp;
use packet::BlobRecycler;
use ring::rand::SystemRandom;
use rpu::Rpu;
use service::Service;
use signature::{KeyPair, KeyPairUtil};
use std::collections::VecDeque;
use std::fs::{File, OpenOptions};
use std::io::{sink, stdin, stdout, BufReader};
@ -21,6 +23,7 @@ use std::time::Duration;
use streamer;
use tpu::Tpu;
use tvu::Tvu;
use untrusted::Input;
//use std::time::Duration;
pub struct FullNode {
@ -38,11 +41,41 @@ pub enum OutFile {
Path(String),
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
/// Fullnode configuration to be stored in file
pub struct Config {
pub network: ReplicatedData,
pkcs8: Vec<u8>,
}
/// Structure to be replicated by the network
impl Config {
pub fn new(bind_addr: &SocketAddr) -> Self {
let rnd = SystemRandom::new();
let pkcs8 = KeyPair::generate_pkcs8(&rnd)
.expect("generate_pkcs8 in mint pub fn new")
.to_vec();
let keypair =
KeyPair::from_pkcs8(Input::from(&pkcs8)).expect("from_pkcs8 in fullnode::Config new");
let pubkey = keypair.pubkey();
let network = ReplicatedData::new_leader_with_pubkey(pubkey, bind_addr);
Config {
network: network,
pkcs8: pkcs8,
}
}
pub fn keypair(&self) -> KeyPair {
KeyPair::from_pkcs8(Input::from(&self.pkcs8))
.expect("from_pkcs8 in fullnode::Config keypair")
}
}
impl FullNode {
pub fn new(
mut node: TestNode,
leader: bool,
infile: InFile,
keypair_for_validator: Option<KeyPair>,
network_entry_for_validator: Option<SocketAddr>,
outfile_for_leader: Option<OutFile>,
) -> FullNode {
@ -75,7 +108,9 @@ impl FullNode {
let testnet_addr = network_entry_for_validator.expect("validator requires entry");
let network_entry_point = ReplicatedData::new_entry_point(testnet_addr);
let keypair = keypair_for_validator.expect("validastor requires keypair");
let server = FullNode::new_validator(
keypair,
bank,
entry_height,
Some(ledger_tail),
@ -184,8 +219,10 @@ impl FullNode {
thread_hdls.extend(rpu.thread_hdls());
let blob_recycler = BlobRecycler::default();
let crdt = Arc::new(RwLock::new(Crdt::new(node.data)));
let (tpu, blob_receiver) = Tpu::new(
bank.clone(),
crdt.clone(),
tick_duration,
node.sockets.transaction,
blob_recycler.clone(),
@ -193,10 +230,7 @@ impl FullNode {
writer,
);
thread_hdls.extend(tpu.thread_hdls());
let crdt = Arc::new(RwLock::new(Crdt::new(node.data)));
let window = FullNode::new_window(ledger_tail, entry_height, &crdt, &blob_recycler);
let ncp = Ncp::new(
crdt.clone(),
window.clone(),
@ -249,6 +283,7 @@ impl FullNode {
/// `-------------------------------`
/// ```
pub fn new_validator(
keypair: KeyPair,
bank: Bank,
entry_height: u64,
ledger_tail: Option<Vec<Entry>>,
@ -284,6 +319,7 @@ impl FullNode {
).expect("Ncp::new");
let tvu = Tvu::new(
Arc::new(keypair),
bank.clone(),
entry_height,
crdt.clone(),
@ -323,16 +359,18 @@ mod tests {
use crdt::TestNode;
use fullnode::FullNode;
use mint::Mint;
use signature::{KeyPair, KeyPairUtil};
use std::sync::atomic::AtomicBool;
use std::sync::Arc;
#[test]
fn validator_exit() {
let tn = TestNode::new();
let kp = KeyPair::new();
let tn = TestNode::new_with_pubkey(kp.pubkey());
let alice = Mint::new(10_000);
let bank = Bank::new(&alice);
let exit = Arc::new(AtomicBool::new(false));
let entry = tn.data.clone();
let v = FullNode::new_validator(bank, 0, None, tn, entry, exit);
let v = FullNode::new_validator(kp, bank, 0, None, tn, entry, exit);
v.close().unwrap();
}
}

1
src/lib.rs
View File

@ -49,6 +49,7 @@ pub mod timing;
pub mod tpu;
pub mod transaction;
pub mod tvu;
pub mod voting;
pub mod window_stage;
pub mod write_stage;
extern crate bincode;

1
src/mint.rs
View File

@ -29,7 +29,6 @@ impl Mint {
tokens,
}
}
pub fn seed(&self) -> Hash {
hash(&self.pkcs8)
}

114
src/replicate_stage.rs
View File

@ -1,57 +1,133 @@
//! The `replicate_stage` replicates transactions broadcast by the leader.
use bank::Bank;
use bincode::serialize;
use crdt::Crdt;
use ledger;
use packet::BlobRecycler;
use result::{Error, Result};
use service::Service;
use signature::KeyPair;
use std::collections::VecDeque;
use std::net::UdpSocket;
use std::sync::mpsc::channel;
use std::sync::mpsc::RecvTimeoutError;
use std::sync::Arc;
use std::sync::{Arc, RwLock};
use std::thread::{self, Builder, JoinHandle};
use std::time::Duration;
use streamer::BlobReceiver;
use streamer::{responder, BlobReceiver, BlobSender};
use timing;
use transaction::Transaction;
use voting::entries_to_votes;
pub struct ReplicateStage {
thread_hdl: JoinHandle<()>,
thread_hdls: Vec<JoinHandle<()>>,
}
const VOTE_TIMEOUT_MS: u64 = 1000;
impl ReplicateStage {
/// Process entry blobs, already in order
fn replicate_requests(bank: &Arc<Bank>, blob_receiver: &BlobReceiver) -> Result<()> {
fn replicate_requests(
keypair: &Arc<KeyPair>,
bank: &Arc<Bank>,
crdt: &Arc<RwLock<Crdt>>,
blob_recycler: &BlobRecycler,
window_receiver: &BlobReceiver,
vote_blob_sender: &BlobSender,
last_vote: &mut u64,
) -> Result<()> {
let timer = Duration::new(1, 0);
let blobs = blob_receiver.recv_timeout(timer)?;
//coalesce all the available blobs into a single vote
let mut blobs = window_receiver.recv_timeout(timer)?;
while let Ok(mut more) = window_receiver.try_recv() {
blobs.append(&mut more);
}
let blobs_len = blobs.len();
let entries = ledger::reconstruct_entries_from_blobs(blobs)?;
let entries = ledger::reconstruct_entries_from_blobs(blobs.clone())?;
let votes = entries_to_votes(&entries);
let res = bank.process_entries(entries);
if res.is_err() {
error!("process_entries {} {:?}", blobs_len, res);
}
res?;
let now = timing::timestamp();
if now - *last_vote > VOTE_TIMEOUT_MS {
let height = res?;
let last_id = bank.last_id();
let shared_blob = blob_recycler.allocate();
let (vote, addr) = {
let mut wcrdt = crdt.write().unwrap();
wcrdt.insert_votes(votes);
//TODO: doesn't seem like there is a synchronous call to get height and id
info!("replicate_stage {} {:?}", height, &last_id[..8]);
let (vote, addr) = wcrdt.new_vote(height, last_id)?;
(vote, addr)
};
{
let mut blob = shared_blob.write().unwrap();
let tx = Transaction::new_vote(&keypair, vote, last_id, 0);
let bytes = serialize(&tx)?;
let len = bytes.len();
blob.data[..len].copy_from_slice(&bytes);
blob.meta.set_addr(&addr);
blob.meta.size = len;
}
*last_vote = now;
vote_blob_sender.send(VecDeque::from(vec![shared_blob]))?;
}
while let Some(blob) = blobs.pop_front() {
blob_recycler.recycle(blob);
}
Ok(())
}
pub fn new(
keypair: Arc<KeyPair>,
bank: Arc<Bank>,
crdt: Arc<RwLock<Crdt>>,
blob_recycler: BlobRecycler,
window_receiver: BlobReceiver,
) -> Self {
let (vote_blob_sender, vote_blob_receiver) = channel();
let send = UdpSocket::bind("0.0.0.0:0").expect("bind");
let t_responder = responder(send, blob_recycler.clone(), vote_blob_receiver);
pub fn new(bank: Arc<Bank>, window_receiver: BlobReceiver) -> Self {
let thread_hdl = Builder::new()
let t_replicate = Builder::new()
.name("solana-replicate-stage".to_string())
.spawn(move || loop {
if let Err(e) = Self::replicate_requests(&bank, &window_receiver) {
match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeoutError(RecvTimeoutError::Timeout) => (),
_ => error!("{:?}", e),
.spawn(move || {
let mut timestamp: u64 = 0;
loop {
if let Err(e) = Self::replicate_requests(
&keypair,
&bank,
&crdt,
&blob_recycler,
&window_receiver,
&vote_blob_sender,
&mut timestamp,
) {
match e {
Error::RecvTimeoutError(RecvTimeoutError::Disconnected) => break,
Error::RecvTimeoutError(RecvTimeoutError::Timeout) => (),
_ => error!("{:?}", e),
}
}
}
})
.unwrap();
ReplicateStage { thread_hdl }
ReplicateStage {
thread_hdls: vec![t_responder, t_replicate],
}
}
}
impl Service for ReplicateStage {
fn thread_hdls(self) -> Vec<JoinHandle<()>> {
vec![self.thread_hdl]
self.thread_hdls
}
fn join(self) -> thread::Result<()> {
self.thread_hdl.join()
for thread_hdl in self.thread_hdls() {
thread_hdl.join()?;
}
Ok(())
}
}

5
src/streamer.rs
View File

@ -7,6 +7,7 @@ use packet::{
Blob, BlobRecycler, PacketRecycler, SharedBlob, SharedBlobs, SharedPackets, BLOB_SIZE,
};
use result::{Error, Result};
use std::cmp;
use std::collections::VecDeque;
use std::mem;
use std::net::{SocketAddr, UdpSocket};
@ -477,7 +478,6 @@ pub fn initialized_window(
{
let mut win = window.write().unwrap();
let me = crdt.read().unwrap().my_data().clone();
assert!(blobs.len() <= win.len());
debug!(
"initialized window entry_height:{} blobs_len:{}",
@ -490,7 +490,8 @@ pub fn initialized_window(
Crdt::index_blobs(&me, &blobs, &mut received).expect("index blobs for initial window");
// populate the window, offset by implied index
for b in blobs {
let diff = cmp::max(blobs.len() as isize - win.len() as isize, 0) as usize;
for b in blobs.into_iter().skip(diff) {
let ix = b.read().unwrap().get_index().expect("blob index");
let pos = (ix % WINDOW_SIZE) as usize;
trace!("caching {} at {}", ix, pos);

6
src/thin_client.rs
View File

@ -57,8 +57,7 @@ impl ThinClient {
trace!("start recv_from");
self.requests_socket.recv_from(&mut buf)?;
trace!("end recv_from");
let resp = deserialize(&buf).expect("deserialize balance in thin_client");
Ok(resp)
deserialize(&buf).or_else(|_| Err(io::Error::new(io::ErrorKind::Other, "deserialize")))
}
pub fn process_response(&mut self, resp: Response) {
@ -317,7 +316,9 @@ mod tests {
server.join().unwrap();
}
// sleep(Duration::from_millis(300)); is unstable
#[test]
#[ignore]
fn test_bad_sig() {
logger::setup();
let leader = TestNode::new();
@ -336,6 +337,7 @@ mod tests {
exit.clone(),
sink(),
);
//TODO: remove this sleep, or add a retry so CI is stable
sleep(Duration::from_millis(300));
let requests_socket = UdpSocket::bind("0.0.0.0:0").unwrap();

13
src/tpu.rs
View File

@ -27,6 +27,7 @@
use bank::Bank;
use banking_stage::BankingStage;
use crdt::Crdt;
use fetch_stage::FetchStage;
use packet::{BlobRecycler, PacketRecycler};
use record_stage::RecordStage;
@ -35,7 +36,7 @@ use sigverify_stage::SigVerifyStage;
use std::io::Write;
use std::net::UdpSocket;
use std::sync::atomic::AtomicBool;
use std::sync::Arc;
use std::sync::{Arc, RwLock};
use std::thread::{self, JoinHandle};
use std::time::Duration;
use streamer::BlobReceiver;
@ -52,6 +53,7 @@ pub struct Tpu {
impl Tpu {
pub fn new<W: Write + Send + 'static>(
bank: Arc<Bank>,
crdt: Arc<RwLock<Crdt>>,
tick_duration: Option<Duration>,
transactions_socket: UdpSocket,
blob_recycler: BlobRecycler,
@ -75,8 +77,13 @@ impl Tpu {
None => RecordStage::new(signal_receiver, &bank.last_id()),
};
let (write_stage, blob_receiver) =
WriteStage::new(bank.clone(), blob_recycler.clone(), writer, entry_receiver);
let (write_stage, blob_receiver) = WriteStage::new(
bank.clone(),
crdt.clone(),
blob_recycler.clone(),
writer,
entry_receiver,
);
let tpu = Tpu {
fetch_stage,

18
src/transaction.rs
View File

@ -47,6 +47,17 @@ pub struct Contract {
pub plan: Plan,
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub struct Vote {
/// We send some gossip specific membershp information through the vote to shortcut
/// liveness voting
/// The version of the CRDT struct that the last_id of this network voted with
pub version: u64,
/// The version of the CRDT struct that has the same network configuration as this one
pub contact_info_version: u64,
// TODO: add signature of the state here as well
}
/// An instruction to progress the smart contract.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum Instruction {
@ -59,6 +70,9 @@ pub enum Instruction {
/// Tell the payment plan that the `NewContract` with `Signature` has been
/// signed by the containing transaction's `PublicKey`.
ApplySignature(Signature),
/// Vote for a PoH that is equal to the lastid of this transaction
NewVote(Vote),
}
/// An instruction signed by a client with `PublicKey`.
@ -135,6 +149,10 @@ impl Transaction {
Self::new_from_instruction(from_keypair, instruction, last_id, 0)
}
pub fn new_vote(from_keypair: &KeyPair, vote: Vote, last_id: Hash, fee: i64) -> Self {
Transaction::new_from_instruction(&from_keypair, Instruction::NewVote(vote), last_id, fee)
}
/// Create and sign a postdated Transaction. Used for unit-testing.
pub fn new_on_date(
from_keypair: &KeyPair,

33
src/tvu.rs
View File

@ -2,13 +2,15 @@
//! 3-stage transaction validation pipeline in software.
//!
//! ```text
//! .------------------------------------------.
//! | TVU |
//! | |
//! | | .------------.
//! | .------------------------>| Validators |
//! | .-------. | | `------------`
//! .--------. | | | .----+---. .-----------. |
//! +<------------------------------------------<+
//! | |
//! | .--------------------------------+---------.
//! | | TVU | |
//! | | | |
//! | | | | .------------.
//! | | .------------+----------->| Validators |
//! | | .-------. | | | `------------`
//! .----+---. | | | .----+---. .----+------. |
//! | Leader |--------->| Blob | | Window | | Replicate | |
//! `--------` | | Fetch |-->| Stage |-->| Stage | |
//! .------------. | | Stage | | | | | |
@ -40,6 +42,7 @@ use crdt::Crdt;
use packet::BlobRecycler;
use replicate_stage::ReplicateStage;
use service::Service;
use signature::KeyPair;
use std::net::UdpSocket;
use std::sync::atomic::AtomicBool;
use std::sync::{Arc, RwLock};
@ -66,6 +69,7 @@ impl Tvu {
/// * `retransmit_socket` - my retransmit socket
/// * `exit` - The exit signal.
pub fn new(
keypair: Arc<KeyPair>,
bank: Arc<Bank>,
entry_height: u64,
crdt: Arc<RwLock<Crdt>>,
@ -76,7 +80,7 @@ impl Tvu {
exit: Arc<AtomicBool>,
) -> Self {
let blob_recycler = BlobRecycler::default();
let (fetch_stage, blob_receiver) = BlobFetchStage::new_multi_socket(
let (fetch_stage, blob_fetch_receiver) = BlobFetchStage::new_multi_socket(
vec![replicate_socket, repair_socket],
exit,
blob_recycler.clone(),
@ -84,16 +88,17 @@ impl Tvu {
//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 (window_stage, blob_receiver) = WindowStage::new(
crdt,
let (window_stage, blob_window_receiver) = WindowStage::new(
crdt.clone(),
window,
entry_height,
retransmit_socket,
blob_recycler.clone(),
blob_receiver,
blob_fetch_receiver,
);
let replicate_stage = ReplicateStage::new(bank, blob_receiver);
let replicate_stage =
ReplicateStage::new(keypair, bank, crdt, blob_recycler, blob_window_receiver);
Tvu {
replicate_stage,
@ -164,7 +169,8 @@ pub mod tests {
fn test_replicate() {
logger::setup();
let leader = TestNode::new();
let target1 = TestNode::new();
let target1_kp = KeyPair::new();
let target1 = TestNode::new_with_pubkey(target1_kp.pubkey());
let target2 = TestNode::new();
let exit = Arc::new(AtomicBool::new(false));
@ -214,6 +220,7 @@ pub mod tests {
let dr_1 = new_ncp(cref1.clone(), target1.sockets.gossip, exit.clone()).unwrap();
let tvu = Tvu::new(
Arc::new(target1_kp),
bank.clone(),
0,
cref1,

23
src/voting.rs Normal file
View File

@ -0,0 +1,23 @@
use entry::Entry;
use hash::Hash;
use signature::PublicKey;
use transaction::{Instruction, Vote};
pub fn entries_to_votes(entries: &Vec<Entry>) -> Vec<(PublicKey, Vote, Hash)> {
entries
.iter()
.flat_map(|entry| {
let vs: Vec<(PublicKey, Vote, Hash)> = entry
.transactions
.iter()
.filter_map(|tx| match &tx.instruction {
&Instruction::NewVote(ref vote) => {
Some((tx.from.clone(), vote.clone(), tx.last_id.clone()))
}
_ => None,
})
.collect();
vs
})
.collect()
}

9
src/write_stage.rs
View File

@ -3,6 +3,7 @@
//! stdout, and then sends the Entry to its output channel.
use bank::Bank;
use crdt::Crdt;
use entry::Entry;
use entry_writer::EntryWriter;
use ledger::Block;
@ -12,10 +13,11 @@ use service::Service;
use std::collections::VecDeque;
use std::io::Write;
use std::sync::mpsc::{channel, Receiver, RecvTimeoutError};
use std::sync::Arc;
use std::sync::{Arc, RwLock};
use std::thread::{self, Builder, JoinHandle};
use std::time::Duration;
use streamer::{BlobReceiver, BlobSender};
use voting::entries_to_votes;
pub struct WriteStage {
thread_hdl: JoinHandle<()>,
@ -25,12 +27,15 @@ impl WriteStage {
/// Process any Entry items that have been published by the RecordStage.
/// continuosly broadcast blobs of entries out
pub fn write_and_send_entries<W: Write>(
crdt: &Arc<RwLock<Crdt>>,
entry_writer: &mut EntryWriter<W>,
blob_sender: &BlobSender,
blob_recycler: &BlobRecycler,
entry_receiver: &Receiver<Vec<Entry>>,
) -> Result<()> {
let entries = entry_receiver.recv_timeout(Duration::new(1, 0))?;
let votes = entries_to_votes(&entries);
crdt.write().unwrap().insert_votes(votes);
entry_writer.write_and_register_entries(&entries)?;
trace!("New blobs? {}", entries.len());
let mut blobs = VecDeque::new();
@ -45,6 +50,7 @@ impl WriteStage {
/// Create a new WriteStage for writing and broadcasting entries.
pub fn new<W: Write + Send + 'static>(
bank: Arc<Bank>,
crdt: Arc<RwLock<Crdt>>,
blob_recycler: BlobRecycler,
writer: W,
entry_receiver: Receiver<Vec<Entry>>,
@ -56,6 +62,7 @@ impl WriteStage {
let mut entry_writer = EntryWriter::new(&bank, writer);
loop {
if let Err(e) = Self::write_and_send_entries(
&crdt,
&mut entry_writer,
&blob_sender,
&blob_recycler,

110
tests/multinode.rs
View File

@ -15,7 +15,6 @@ use solana::signature::{KeyPair, KeyPairUtil, PublicKey};
use solana::streamer::default_window;
use solana::thin_client::ThinClient;
use std::fs::File;
use std::mem;
use std::net::UdpSocket;
use std::sync::atomic::AtomicBool;
use std::sync::{Arc, RwLock};
@ -92,14 +91,23 @@ fn test_multi_node_validator_catchup_from_zero() {
let bob_pubkey = KeyPair::new().pubkey();
let (alice, ledger_path) = genesis(10_000);
let server = FullNode::new(leader, true, InFile::Path(ledger_path.clone()), None, None);
let server = FullNode::new(
leader,
true,
InFile::Path(ledger_path.clone()),
None,
None,
None,
);
let mut nodes = vec![server];
for _ in 0..N {
let validator = TestNode::new();
let keypair = KeyPair::new();
let validator = TestNode::new_with_pubkey(keypair.pubkey());
let mut val = FullNode::new(
validator,
false,
InFile::Path(ledger_path.clone()),
Some(keypair),
Some(leader_data.contact_info.ncp),
None,
);
@ -128,10 +136,13 @@ fn test_multi_node_validator_catchup_from_zero() {
success = 0;
// start up another validator, converge and then check everyone's balances
let keypair = KeyPair::new();
let validator = TestNode::new_with_pubkey(keypair.pubkey());
let val = FullNode::new(
TestNode::new(),
validator,
false,
InFile::Path(ledger_path.clone()),
Some(keypair),
Some(leader_data.contact_info.ncp),
None,
);
@ -155,7 +166,7 @@ fn test_multi_node_validator_catchup_from_zero() {
for server in servers.iter() {
let mut client = mk_client(server);
info!("1server: {:x}", server.debug_id());
for _ in 0..10 {
for _ in 0..15 {
if let Ok(bal) = client.poll_get_balance(&bob_pubkey) {
info!("validator balance {}", bal);
if bal == leader_balance {
@ -182,14 +193,23 @@ fn test_multi_node_basic() {
let leader_data = leader.data.clone();
let bob_pubkey = KeyPair::new().pubkey();
let (alice, ledger_path) = genesis(10_000);
let server = FullNode::new(leader, true, InFile::Path(ledger_path.clone()), None, None);
let server = FullNode::new(
leader,
true,
InFile::Path(ledger_path.clone()),
None,
None,
None,
);
let mut nodes = vec![server];
for _ in 0..N {
let validator = TestNode::new();
let val = FullNode::new(
let keypair = KeyPair::new();
let validator = TestNode::new_with_pubkey(keypair.pubkey());
FullNode::new(
validator,
false,
InFile::Path(ledger_path.clone()),
Some(keypair),
Some(leader_data.contact_info.ncp),
None,
);
@ -233,6 +253,7 @@ fn test_boot_validator_from_file() {
true,
InFile::Path(ledger_path.clone()),
None,
None,
Some(OutFile::Path(ledger_path.clone())),
);
let leader_balance =
@ -242,12 +263,14 @@ fn test_boot_validator_from_file() {
send_tx_and_retry_get_balance(&leader_data, &alice, &bob_pubkey, Some(1000)).unwrap();
assert_eq!(leader_balance, 1000);
let validator = TestNode::new();
let keypair = KeyPair::new();
let validator = TestNode::new_with_pubkey(keypair.pubkey());
let validator_data = validator.data.clone();
let val_fullnode = FullNode::new(
validator,
false,
InFile::Path(ledger_path.clone()),
Some(keypair),
Some(leader_data.contact_info.ncp),
None,
);
@ -269,7 +292,8 @@ fn create_leader(ledger_path: &str) -> (ReplicatedData, FullNode) {
true,
InFile::Path(ledger_path.to_string()),
None,
Some(OutFile::Path(ledger_path.to_string())),
None,
Some(OutFile::Path(ledger_path.clone())),
);
(leader_data, leader_fullnode)
}
@ -312,12 +336,14 @@ fn test_leader_restart_validator_start_from_old_ledger() {
let (leader_data, leader_fullnode) = create_leader(&ledger_path);
// start validator from old ledger
let validator = TestNode::new();
let keypair = KeyPair::new();
let validator = TestNode::new_with_pubkey(keypair.pubkey());
let validator_data = validator.data.clone();
let val_fullnode = FullNode::new(
validator,
false,
InFile::Path(stale_ledger_path.clone()),
Some(keypair),
Some(leader_data.contact_info.ncp),
None,
);
@ -352,7 +378,7 @@ fn test_leader_restart_validator_start_from_old_ledger() {
#[ignore]
fn test_multi_node_dynamic_network() {
logger::setup();
const N: usize = 25;
const N: usize = 60;
let leader = TestNode::new();
let bob_pubkey = KeyPair::new().pubkey();
let (alice, ledger_path) = genesis(100_000);
@ -362,6 +388,7 @@ fn test_multi_node_dynamic_network() {
true,
InFile::Path(ledger_path.clone()),
None,
None,
Some(OutFile::Path(ledger_path.clone())),
);
info!("{:x} LEADER", leader_data.debug_id());
@ -372,19 +399,25 @@ fn test_multi_node_dynamic_network() {
send_tx_and_retry_get_balance(&leader_data, &alice, &bob_pubkey, Some(1000)).unwrap();
assert_eq!(leader_balance, 1000);
let mut validators: Vec<(ReplicatedData, FullNode)> = (0..N)
let validators: Vec<(ReplicatedData, FullNode)> = (0..N)
.into_iter()
.map(|_| {
let validator = TestNode::new();
.map(|n| {
let keypair = KeyPair::new();
let validator = TestNode::new_with_pubkey(keypair.pubkey());
let rd = validator.data.clone();
//send some tokens to the new validator
let bal =
send_tx_and_retry_get_balance(&leader_data, &alice, &keypair.pubkey(), Some(500));
assert_eq!(bal, Some(500));
let val = FullNode::new(
validator,
false,
InFile::Path(ledger_path.clone()),
Some(keypair),
Some(leader_data.contact_info.ncp),
Some(OutFile::Path(ledger_path.clone())),
);
info!("{:x} VALIDATOR", rd.debug_id());
info!("started[{}/{}] {:x}", n, N, rd.debug_id());
(rd, val)
})
.collect();
@ -395,13 +428,19 @@ fn test_multi_node_dynamic_network() {
let leader_balance =
send_tx_and_retry_get_balance(&leader_data, &alice, &bob_pubkey, Some(expected))
.unwrap();
assert_eq!(leader_balance, expected);
if leader_balance != expected {
info!(
"leader dropped transaction {} {:?} {:?}",
i, leader_balance, expected
);
}
//verify all validators have the same balance
for i in 0..10 {
{
let mut success = 0usize;
let mut distance = 0i64;
for server in validators.iter() {
let mut client = mk_client(&server.0);
trace!("{:x} {} get_balance start", server.0.debug_id(), i);
let getbal = retry_get_balance(&mut client, &bob_pubkey, Some(expected));
trace!(
"{:x} {} get_balance: {:?} expected: {}",
@ -411,49 +450,23 @@ fn test_multi_node_dynamic_network() {
expected
);
let bal = getbal.unwrap_or(0);
distance += (expected - bal) / 500;
distance += (leader_balance - bal) / 500;
if let Some(bal) = getbal {
if bal == leader_balance {
success += 1;
}
}
}
if success == validators.len() {
break;
}
sleep(Duration::from_millis(i * 100));
info!(
"SUCCESS {} out of {} distance: {}",
"SUCCESS[{}] {} out of {} distance: {}",
i,
success,
validators.len(),
distance
);
//assert_eq!(success, validators.len());
}
let val = {
let validator = TestNode::new();
let rd = validator.data.clone();
let val = FullNode::new(
validator,
false,
InFile::Path(ledger_path.clone()),
Some(leader_data.contact_info.ncp),
Some(OutFile::Path(ledger_path.clone())),
);
info!("{:x} ADDED", rd.debug_id());
(rd, val)
};
let old_val = mem::replace(&mut validators[i], val);
// this should be almost true, or at least validators.len() - 1 while the other node catches up
//assert!(success == validators.len());
//kill a validator
old_val.1.close().unwrap();
info!("{:x} KILLED", old_val.0.debug_id());
//add a new one
}
for (_, node) in validators {
node.close().unwrap();
}
@ -490,6 +503,7 @@ fn retry_get_balance(
if expected.is_none() || run == LAST {
return out.ok().clone();
}
trace!("retry_get_balance[{}] {:?} {:?}", run, out, expected);
if let (Some(e), Ok(o)) = (expected, out) {
if o == e {
return Some(o);