update source files

Author: hypercube-lab

.gitignore

@@ -8,7 +8,7 @@ Cargo.lock
 # node configuration files
 /config/
 /config-private/
-/config-drone/
+/config-faucet/
 /config-validator/
 /config-client/
 /multinode-demo/test/config-client/

Cargo.toml

@@ -30,8 +30,8 @@ name = "hypercube-bench-tps"
 path = "src/bin/bench-tps.rs"
 
 [[bin]]
-name = "hypercube-drone"
-path = "src/bin/drone.rs"
+name = "hypercube-faucet"
+path = "src/bin/faucet.rs"
 
 [[bin]]
 name = "hypercube-replicator"

src/bin/bench-tps.rs

@@ -12,7 +12,7 @@ use influx_db_client as influxdb;
 use rayon::prelude::*;
 use hypercube::client::mk_client;
 use hypercube::blockthread::{BlockThread, NodeInfo};
-use hypercube::drone::DRONE_PORT;
+use hypercube::faucet::DRONE_PORT;
 use hypercube::hash::Hash;
 use hypercube::logger;
 use hypercube::metrics;
@@ -152,7 +152,7 @@ fn send_barrier_transaction(barrier_client: &mut ThinClient, last_id: &mut Hash,
             break;
         }
 
-        // Timeout after 3 minutes.  When running a CPU-only leader+validator+drone+bench-tps on a dev
+        // Timeout after 3 minutes.  When running a CPU-only leader+validator+faucet+bench-tps on a dev
         // machine, some batches of transactions can take upwards of 1 minute...
         if duration_ms > 1000 * 60 * 3 {
             println!("Error: Couldn't confirm barrier transaction!");
@@ -273,8 +273,8 @@ fn do_tx_transfers(
 }
 
 fn airdrop_tokens(client: &mut ThinClient, leader: &NodeInfo, id: &Keypair, tx_count: i64) {
-    let mut drone_addr = leader.contact_info.tx_creator;
-    drone_addr.set_port(DRONE_PORT);
+    let mut faucet_addr = leader.contact_info.tx_creator;
+    faucet_addr.set_port(DRONE_PORT);
 
     let starting_balance = client.poll_get_balance(&id.pubkey()).unwrap_or(0);
     metrics_submit_token_balance(starting_balance);
@@ -285,14 +285,14 @@ fn airdrop_tokens(client: &mut ThinClient, leader: &NodeInfo, id: &Keypair, tx_c
         println!(
             "Airdropping {:?} tokens from {} for {}",
             airdrop_amount,
-            drone_addr,
+            faucet_addr,
             id.pubkey(),
         );
 
-        if let Err(e) = request_airdrop(&drone_addr, &id.pubkey(), airdrop_amount as u64) {
+        if let Err(e) = request_airdrop(&faucet_addr, &id.pubkey(), airdrop_amount as u64) {
             panic!(
                 "Error requesting airdrop: {:?} to addr: {:?} amount: {}",
-                e, drone_addr, airdrop_amount
+                e, faucet_addr, airdrop_amount
             );
         }
 

src/bin/drone.rs

@@ -11,7 +11,7 @@ extern crate tokio_codec;
 use bincode::{deserialize, serialize};
 use bytes::Bytes;
 use clap::{App, Arg};
-use hypercube::drone::{Drone, DroneRequest, DRONE_PORT};
+use hypercube::faucet::{Drone, DroneRequest, DRONE_PORT};
 use hypercube::logger;
 use hypercube::metrics::set_panic_hook;
 use hypercube::signature::read_keypair;
@@ -37,8 +37,8 @@ macro_rules! socketaddr {
 
 fn main() -> Result<(), Box<error::Error>> {
     logger::setup();
-    set_panic_hook("drone");
-    let matches = App::new("drone")
+    set_panic_hook("faucet");
+    let matches = App::new("faucet")
         .version(crate_version!())
         .arg(
             Arg::with_name("network")
@@ -61,7 +61,7 @@ fn main() -> Result<(), Box<error::Error>> {
                 .long("slice")
                 .value_name("SECS")
                 .takes_value(true)
-                .help("Time slice over which to limit requests to drone"),
+                .help("Time slice over which to limit requests to faucet"),
         ).arg(
             Arg::with_name("cap")
                 .long("cap")
@@ -95,45 +95,45 @@ fn main() -> Result<(), Box<error::Error>> {
         request_cap = None;
     }
 
-    let drone_addr = socketaddr!(0, DRONE_PORT);
+    let faucet_addr = socketaddr!(0, DRONE_PORT);
 
-    let drone = Arc::new(Mutex::new(Drone::new(
+    let faucet = Arc::new(Mutex::new(Drone::new(
         mint_keypair,
-        drone_addr,
+        faucet_addr,
         network,
         time_slice,
         request_cap,
     )));
 
-    let drone1 = drone.clone();
+    let faucet1 = faucet.clone();
     thread::spawn(move || loop {
-        let time = drone1.lock().unwrap().time_slice;
+        let time = faucet1.lock().unwrap().time_slice;
         thread::sleep(time);
-        drone1.lock().unwrap().clear_request_count();
+        faucet1.lock().unwrap().clear_request_count();
     });
 
-    let socket = TcpListener::bind(&drone_addr).unwrap();
-    println!("Drone started. Listening on: {}", drone_addr);
+    let socket = TcpListener::bind(&faucet_addr).unwrap();
+    println!("Drone started. Listening on: {}", faucet_addr);
     let done = socket
         .incoming()
         .map_err(|e| println!("failed to accept socket; error = {:?}", e))
         .for_each(move |socket| {
-            let drone2 = drone.clone();
-            // let client_ip = socket.peer_addr().expect("drone peer_addr").ip();
+            let faucet2 = faucet.clone();
+            // let client_ip = socket.peer_addr().expect("faucet peer_addr").ip();
             let framed = BytesCodec::new().framed(socket);
             let (writer, reader) = framed.split();
 
             let processor = reader.and_then(move |bytes| {
                 let req: DroneRequest = deserialize(&bytes).or_else(|err| {
                     Err(io::Error::new(
                         io::ErrorKind::Other,
-                        format!("deserialize packet in drone: {:?}", err),
+                        format!("deserialize packet in faucet: {:?}", err),
                     ))
                 })?;
 
                 println!("Airdrop requested...");
-                // let res = drone2.lock().unwrap().check_rate_limit(client_ip);
-                let res1 = drone2.lock().unwrap().send_airdrop(req);
+                // let res = faucet2.lock().unwrap().check_rate_limit(client_ip);
+                let res1 = faucet2.lock().unwrap().send_airdrop(req);
                 match res1 {
                     Ok(_) => println!("Airdrop sent!"),
                     Err(_) => println!("Request limit reached for this time slice"),
@@ -143,7 +143,7 @@ fn main() -> Result<(), Box<error::Error>> {
                 let response_vec = serialize(&response).or_else(|err| {
                     Err(io::Error::new(
                         io::ErrorKind::Other,
-                        format!("serialize signature in drone: {:?}", err),
+                        format!("serialize signature in faucet: {:?}", err),
                     ))
                 })?;
                 let response_bytes = Bytes::from(response_vec.clone());

src/bin/fullnode.rs

@@ -10,7 +10,7 @@ extern crate hypercube;
 use clap::{App, Arg};
 use hypercube::client::mk_client;
 use hypercube::blockthread::Node;
-use hypercube::drone::DRONE_PORT;
+use hypercube::faucet::DRONE_PORT;
 use hypercube::fullnode::{Config, Fullnode, FullnodeReturnType};
 use hypercube::logger;
 use hypercube::metrics::set_panic_hook;
@@ -95,8 +95,8 @@ fn main() -> () {
 
     let mut client = mk_client(&leader);
 
-    // TODO: maybe have the drone put itself in gossip somewhere instead of hardcoding?
-    let drone_addr = match network {
+    // TODO: maybe have the faucet put itself in gossip somewhere instead of hardcoding?
+    let faucet_addr = match network {
         Some(network) => SocketAddr::new(network.ip(), DRONE_PORT),
         None => SocketAddr::new(ncp.ip(), DRONE_PORT),
     };
@@ -110,14 +110,14 @@ fn main() -> () {
             break;
         }
 
-        info!("requesting airdrop from {}", drone_addr);
+        info!("requesting airdrop from {}", faucet_addr);
         loop {
-            if request_airdrop(&drone_addr, &pubkey, 50).is_ok() {
+            if request_airdrop(&faucet_addr, &pubkey, 50).is_ok() {
                 break;
             }
             info!(
-                "airdrop request, is the drone address correct {:?}, drone running?",
-                drone_addr
+                "airdrop request, is the faucet address correct {:?}, faucet running?",
+                faucet_addr
             );
             sleep(Duration::from_secs(2));
         }

src/bin/wallet.rs

@@ -5,7 +5,7 @@ extern crate dirs;
 extern crate hypercube;
 
 use clap::{App, Arg, ArgMatches, SubCommand};
-use hypercube::drone::DRONE_PORT;
+use hypercube::faucet::DRONE_PORT;
 use hypercube::logger;
 use hypercube::rpc::RPC_PORT;
 use hypercube::signature::{read_keypair, KeypairUtil};
@@ -51,8 +51,8 @@ pub fn parse_args(matches: &ArgMatches) -> Result<WalletConfig, Box<error::Error
 
     let leader = poll_gossip_for_leader(network, timeout)?;
 
-    let mut drone_addr = leader.contact_info.tx_creator;
-    drone_addr.set_port(DRONE_PORT);
+    let mut faucet_addr = leader.contact_info.tx_creator;
+    faucet_addr.set_port(DRONE_PORT);
 
     let rpc_addr = if let Some(proxy) = matches.value_of("proxy") {
         proxy.to_string()
@@ -72,7 +72,7 @@ pub fn parse_args(matches: &ArgMatches) -> Result<WalletConfig, Box<error::Error
     Ok(WalletConfig {
         leader,
         id,
-        drone_addr, // TODO: Add an option for this.
+        faucet_addr, // TODO: Add an option for this.
         rpc_addr,
         command,
     })