wip. sketching the async generator loop

benchmarks/transactions-generator/src/lib.rs

@@ -15,6 +15,8 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use std::thread;
 use std::time::{Duration, Instant};
+use std::sync::atomic::Ordering;
+use tokio::time;
 
 
 pub mod account;
@@ -68,6 +70,64 @@ impl TxGenerator {
         })
     }
 
+    pub fn start(self: &mut Self)-> anyhow::Result<()> {
+        const AMOUNT: near_primitives::types::Balance = 1_000;
+        if let Some(_) = self.runner {
+            anyhow::bail!("attempt to (re)start the running transaction generator");
+        }
+        let accounts = account::accounts_from_dir(&self.params.accounts_path)?;
+        if accounts.is_empty() {
+            anyhow::bail!("No active accounts available");
+        }
+        let client_sender = self.client_sender.clone();
+        let view_client_sender = self.view_client_sender.clone();
+        let stop_token = Arc::new(AtomicBool::new(false));
+        let stop = stop_token.clone();
+
+        let mut tx_interval = time::interval(Duration::from_micros(1_000_000/self.params.tps));
+        let mut block_interval = time::interval(Duration::from_secs(5));
+
+        // let mut interval = time::interval(Duration::from_millis(100));
+        let _ = tokio::spawn(async move {
+            let mut rnd: StdRng = SeedableRng::from_entropy();
+            while !stop.load(Ordering::Acquire) {
+                tx_interval.tick().await;
+                block_interval.tick().await;
+                // hierwasik
+
+                let block_hash = CryptoHash::default(); // todo(slavas): fix before merge
+
+                let id_sender = Uniform::from(0..accounts.len()).sample(&mut rnd);
+                let id_recv = loop {
+                    let candidate = Uniform::from(0..accounts.len()).sample(&mut rnd);
+                    if candidate != id_sender {
+                        break candidate;
+                    }
+                };
+
+                let sender = &accounts[id_sender];
+                let receiver = &accounts[id_recv];
+                let transaction = SignedTransaction::send_money(
+                    sender.nonce + 1,
+                    sender.id.clone(),
+                    receiver.id.clone(),
+                    &sender.as_signer(),
+                    AMOUNT,
+                    block_hash.clone(),
+                );
+
+                client_sender.tx_request_sender.send(ProcessTxRequest{
+                    transaction, is_forwarded: false, check_only: false});
+
+                let rsp = view_client_sender.block_request_sender.send_async(
+                    GetBlock(BlockReference::latest())).await?;
+
+            }
+        });
+
+        Ok(())
+    }
+
     fn run(self: &mut Self)-> anyhow::Result<()> {
         const AMOUNT: near_primitives::types::Balance = 1_000;
         if let Some(_) = self.runner {