Small improvements in tools.

Author: bhat

src/bin/register.rs

@@ -1,13 +1,14 @@
 use duino_miner::error::MinerError;
 
-use tokio::net::TcpStream;
+use std::time::Duration;
 
 use rand::{thread_rng, Rng};
 use rand::distributions::Alphanumeric;
 
-use clap::{AppSettings, Clap};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
 
+use clap::{AppSettings, Clap};
 
 #[derive(Clap)]
 #[clap(version = "0.1", author = "Black H. <[email protected]>")]
@@ -17,39 +18,46 @@ struct Opts {
     host: String,
     #[clap(short, long, default_value = "2811")]
     port: u16,
+    #[clap(short, long, default_value = "1")]
+    count: u32,
 }
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let opts: Opts = Opts::parse();
 
-    let mut username = parity_wordlist::random_phrase(2);
-    username.retain(|c| !c.is_whitespace());
-    let password: String = thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(16)
-        .map(char::from)
-        .collect();
+    for _ in 0..opts.count {
+        let mut username = parity_wordlist::random_phrase(2);
+        username.retain(|c| !c.is_whitespace());
+        let password: String = thread_rng()
+            .sample_iter(&Alphanumeric)
+            .take(16)
+            .map(char::from)
+            .collect();
+
+        let mut stream = TcpStream::connect(
+            format!("{}:{}", opts.host, opts.port)).await.map_err(|_| MinerError::Connection)?;
 
-    let mut stream = TcpStream::connect(
-        format!("{}:{}", opts.host, opts.port)).await.map_err(|_| MinerError::Connection)?;
+        println!("Connected to pool {}:{}", opts.host, opts.port);
 
-    println!("Connected to pool {}:{}", opts.host, opts.port);
+        let mut cmd_in: [u8; 200] = [0; 200];
 
-    let mut cmd_in: [u8; 200] = [0; 200];
+        let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+        println!("version: {}", std::str::from_utf8(&cmd_in[..n])?);
 
-    let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
-    println!("version: {}", std::str::from_utf8(&cmd_in[..n])?);
+        let cmd_job = format!("REGI,{},{},{}@gmail.com\n", username, password, username);
+        stream.write(cmd_job.as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
+        let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+        let reg_status = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?;
 
-    let cmd_job = format!("REGI,{},{},{}@gmail.com\n", username, password, username);
-    stream.write(cmd_job.as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
-    let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
-    let reg_status = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?;
+        if reg_status != "OK" {
+            println!("register failed: {}", reg_status);
+            break;
+        }
 
-    if reg_status != "OK" {
-        println!("register failed: {}", reg_status);
-    } else {
         println!("registered {} with {}", username, password);
+
+        tokio::time::sleep(Duration::from_secs(4)).await;
     }
 
     Ok(())

src/bin/transfer.rs

@@ -39,21 +39,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let c_serial = tokio::fs::read_to_string(opts.config_file).await?;
     let c: Config = serde_yaml::from_str(c_serial.as_str())?;
 
-    for account in c.accounts {
-        if account.username == c.main_account {
-            continue;
-        }
-
-        let mut stream = TcpStream::connect(
-            format!("{}:{}", c.host, c.port)).await.map_err(|_| MinerError::Connection)?;
-
-        println!("Connected to pool {}:{}", c.host, c.port);
+    let mut stream = TcpStream::connect(
+        format!("{}:{}", c.host, c.port)).await.map_err(|_| MinerError::Connection)?;
 
-        let mut cmd_in: [u8; 200] = [0; 200];
+    println!("Connected to pool {}:{}", c.host, c.port);
 
-        let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
-        println!("version: {}", std::str::from_utf8(&cmd_in[..n])?);
+    let mut cmd_in: [u8; 200] = [0; 200];
+    let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+    println!("version: {}", std::str::from_utf8(&cmd_in[..n])?);
 
+    for account in c.accounts {
         let cmd_job = format!("LOGI,{},{}\n", account.username, account.password);
         stream.write(cmd_job.as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
         let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
@@ -69,6 +64,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         let balance: f32 = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?.parse()?;
         println!("account {} has balance {}", account.username, balance);
 
+        if account.username == c.main_account {
+            continue;
+        }
+
         let balance = balance as u32;
 
         if balance > 100 || opts.force {