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

Use leader.json or ReplicatedData to get ports for drone

This commit is contained in:
Tyera Eulberg 2018-06-24 01:37:18 -06:00 committed by Greg Fitzgerald
parent 45b2549fa9
commit 80c01dc085
2 changed files with 43 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/bin/drone.rs
View File

@ -11,17 +11,16 @@ extern crate tokio_io;
use atty::{is, Stream as atty_stream};
use bincode::deserialize;
use getopts::Options;
use solana::crdt::get_ip_addr;
use solana::crdt::{get_ip_addr, ReplicatedData};
use solana::drone::{Drone, DroneRequest};
use solana::mint::MintDemo;
// use solana::signature::GenKeys;
use std::env;
use std::fs::File;
use std::io::{stdin, Read};
use std::net::SocketAddr;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::process::exit;
use std::sync::{Arc, Mutex};
use std::thread;
// use std::time::Duration;
use tokio::net::TcpListener;
use tokio::prelude::*;
use tokio_codec::{BytesCodec, Decoder};
@ -43,6 +42,7 @@ fn main() {
"time slice over which to limit token requests to drone",
);
opts.optopt("c", "", "cap", "request limit for time slice");
opts.optopt("l", "", "leader", "leader.json");
opts.optflag("h", "help", "print help");
let args: Vec<String> = env::args().collect();
let matches = match opts.parse(&args[1..]) {
@ -77,6 +77,12 @@ fn main() {
} else {
request_cap = None;
}
let leader = if matches.opt_present("l") {
read_leader(matches.opt_str("l").unwrap())
} else {
let server_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8000);
ReplicatedData::new_leader(&server_addr)
};
if is(atty_stream::Stdin) {
eprintln!("nothing found on stdin, expected a json file");
@ -99,12 +105,12 @@ fn main() {
let mut drone_addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
drone_addr.set_ip(get_ip_addr().unwrap());
let mut server_addr = drone_addr.clone();
server_addr.set_port(8000);
let drone = Arc::new(Mutex::new(Drone::new(
mint_keypair,
drone_addr,
server_addr,
leader.transactions_addr,
leader.requests_addr,
time_slice,
request_cap,
)));
@ -156,3 +162,7 @@ fn main() {
});
tokio::run(done);
}
fn read_leader(path: String) -> ReplicatedData {
let file = File::open(path.clone()).expect(&format!("file not found: {}", path));
serde_json::from_reader(file).expect(&format!("failed to parse {}", path))
}

56
src/drone.rs
View File

@ -27,7 +27,8 @@ pub struct Drone {
mint_keypair: KeyPair,
ip_cache: Vec<IpAddr>,
_airdrop_addr: SocketAddr,
server_addr: SocketAddr,
transactions_addr: SocketAddr,
requests_addr: SocketAddr,
pub time_slice: Duration,
request_cap: u64,
pub request_current: u64,
@ -37,7 +38,8 @@ impl Drone {
pub fn new(
mint_keypair: KeyPair,
_airdrop_addr: SocketAddr,
server_addr: SocketAddr,
transactions_addr: SocketAddr,
requests_addr: SocketAddr,
time_input: Option<u64>,
request_cap_input: Option<u64>,
) -> Drone {
@ -53,19 +55,14 @@ impl Drone {
mint_keypair,
ip_cache: Vec::new(),
_airdrop_addr,
server_addr,
transactions_addr,
requests_addr,
time_slice,
request_cap,
request_current: 0,
}
}
pub fn new_from_server_addr(&mut self, addr_type: ServerAddr) -> SocketAddr {
let mut new_addr = self.server_addr.clone();
new_addr.set_port(self.server_addr.port() + addr_type as u16);
new_addr
}
pub fn check_request_limit(&mut self, request_amount: u64) -> bool {
(self.request_current + request_amount) <= self.request_cap
}
@ -101,9 +98,9 @@ impl Drone {
let transactions_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
let mut client = ThinClient::new(
self.new_from_server_addr(ServerAddr::RequestsAddr),
self.requests_addr,
requests_socket,
self.new_from_server_addr(ServerAddr::TransactionsAddr),
self.transactions_addr,
transactions_socket,
);
let last_id = client.get_last_id();
@ -131,14 +128,6 @@ impl Drone {
}
}
pub enum ServerAddr {
TransactionsAddr,
GossipAddr,
ReplicateAddr,
RequestsAddr,
RepaidAddr,
}
#[cfg(test)]
mod tests {
use bank::Bank;
@ -161,8 +150,9 @@ mod tests {
let keypair = KeyPair::new();
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
addr.set_ip(get_ip_addr().unwrap());
let server_addr = addr.clone();
let mut drone = Drone::new(keypair, addr, server_addr, None, Some(3));
let transactions_addr = "0.0.0.0:0".parse().unwrap();
let requests_addr = "0.0.0.0:0".parse().unwrap();
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, Some(3));
assert!(drone.check_request_limit(1));
drone.request_current = 3;
assert!(!drone.check_request_limit(1));
@ -173,8 +163,9 @@ mod tests {
let keypair = KeyPair::new();
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
addr.set_ip(get_ip_addr().unwrap());
let server_addr = addr.clone();
let mut drone = Drone::new(keypair, addr, server_addr, None, None);
let transactions_addr = "0.0.0.0:0".parse().unwrap();
let requests_addr = "0.0.0.0:0".parse().unwrap();
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, None);
drone.request_current = drone.request_current + 256;
assert_eq!(drone.request_current, 256);
drone.clear_request_count();
@ -186,8 +177,9 @@ mod tests {
let keypair = KeyPair::new();
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
addr.set_ip(get_ip_addr().unwrap());
let server_addr = addr.clone();
let mut drone = Drone::new(keypair, addr, server_addr, None, None);
let transactions_addr = "0.0.0.0:0".parse().unwrap();
let requests_addr = "0.0.0.0:0".parse().unwrap();
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, None);
let ip = "127.0.0.1".parse().expect("create IpAddr from string");
assert_eq!(drone.ip_cache.len(), 0);
drone.add_ip_to_cache(ip);
@ -200,8 +192,9 @@ mod tests {
let keypair = KeyPair::new();
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
addr.set_ip(get_ip_addr().unwrap());
let server_addr = addr.clone();
let mut drone = Drone::new(keypair, addr, server_addr, None, None);
let transactions_addr = "0.0.0.0:0".parse().unwrap();
let requests_addr = "0.0.0.0:0".parse().unwrap();
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, None);
let ip = "127.0.0.1".parse().expect("create IpAddr from string");
assert_eq!(drone.ip_cache.len(), 0);
drone.add_ip_to_cache(ip);
@ -216,10 +209,11 @@ mod tests {
let keypair = KeyPair::new();
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
addr.set_ip(get_ip_addr().unwrap());
let server_addr = addr.clone();
let transactions_addr = "0.0.0.0:0".parse().unwrap();
let requests_addr = "0.0.0.0:0".parse().unwrap();
let time_slice: Option<u64> = None;
let request_cap: Option<u64> = None;
let drone = Drone::new(keypair, addr, server_addr, time_slice, request_cap);
let drone = Drone::new(keypair, addr, transactions_addr, requests_addr, time_slice, request_cap);
assert_eq!(drone.time_slice, Duration::new(TIME_SLICE, 0));
assert_eq!(drone.request_cap, REQUEST_CAP);
}
@ -258,6 +252,7 @@ mod tests {
alice.keypair(),
addr,
leader.data.transactions_addr,
leader.data.requests_addr,
None,
Some(5_000_050),
);
@ -279,7 +274,8 @@ mod tests {
let requests_socket = UdpSocket::bind("0.0.0.0:0").expect("drone bind to requests socket");
let transactions_socket =
UdpSocket::bind("0.0.0.0:0").expect("drone bind to transactions socket");
println!("trans: {:?}", leader.data.transactions_addr);
println!("req: {:?}", leader.data.requests_addr);
let mut client = ThinClient::new(
leader.data.requests_addr,
requests_socket,