Add airdrop looper

Author: sungoki

src/cli.rs

@@ -16,7 +16,7 @@ const LOCATION_HELP: &str =
 - Solana Program Registry artifact, for example `spr:QuarryProtocol/quarry_mine`
 ";
 
-#[derive(Clone, Debug, clap::Subcommand)]
+#[derive(Clone, Debug, clap::Subcommand, PartialEq, Eq)]
 pub enum SubCommand {
     /// Initializes a new Goki workspace.
     Init,
@@ -33,6 +33,16 @@ pub enum SubCommand {
         /// Airdrop request amount in SOL.
         #[clap(default_value = "1")]
         amount: String,
+
+        /// Number of times to request an airdrop.
+        #[clap(short, long)]
+        #[clap(default_value = "1")]
+        iterations: u32,
+
+        /// Interval between airdrop requests, in milliseconds.
+        #[clap(short, long)]
+        #[clap(default_value = "5000")]
+        interval: u64,
     },
     /// Transfers SOL from a wallet.
     Transfer {
@@ -143,17 +153,30 @@ pub struct Opts {
 
 impl Opts {
     pub async fn run(&self) -> Result<()> {
+        if self.command.clone() == SubCommand::Init {
+            return subcommands::init::process(&self.workspace_path);
+        }
+
         let workspace = Workspace::load(&self.workspace_path)?;
         println!("Using workspace at {}", workspace.path.display());
         match self.command.clone() {
-            SubCommand::Init => {
-                subcommands::init::process(&workspace)?;
-            }
+            SubCommand::Init => {}
             SubCommand::Show => {
                 subcommands::show::process(&workspace)?;
             }
-            SubCommand::Airdrop { cluster, amount } => {
-                subcommands::airdrop::process(&workspace, cluster, amount.as_str())?;
+            SubCommand::Airdrop {
+                cluster,
+                amount,
+                iterations,
+                interval,
+            } => {
+                subcommands::airdrop::process(
+                    &workspace,
+                    cluster,
+                    amount.as_str(),
+                    iterations,
+                    interval,
+                )?;
             }
             SubCommand::Transfer {
                 cluster,

src/subcommands/airdrop.rs

@@ -1,17 +1,28 @@
 use anchor_client::Cluster;
 use anyhow::{format_err, Result};
+use std::{thread, time::Duration};
 
 use crate::workspace::Workspace;
 
-pub fn process(workspace: &Workspace, cluster: Cluster, amount: &str) -> Result<()> {
+pub fn process(
+    workspace: &Workspace,
+    cluster: Cluster,
+    amount: &str,
+    iterations: u32,
+    interval: u64,
+) -> Result<()> {
     if cluster == Cluster::Mainnet {
         return Err(format_err!("cannot request an airdrop from mainnet"));
     }
 
-    workspace.exec_deployer_command(&cluster, |cmd| {
-        cmd.arg("airdrop").arg(amount);
-        Ok(())
-    })?;
+    for _ in 0..iterations {
+        workspace.exec_deployer_command(&cluster, |cmd| {
+            cmd.arg("airdrop").arg(amount);
+            Ok(())
+        })?;
+
+        thread::sleep(Duration::from_millis(interval));
+    }
 
     Ok(())
 }

src/subcommands/init.rs

@@ -9,14 +9,22 @@ use std::{fs, path::Path};
 use crate::utils::{exec_command, gen_keypair_file};
 use crate::{config::Config, workspace::Workspace};
 
-pub fn process(workspace: &Workspace) -> Result<()> {
-    if Config::discover()?.is_some() {
-        println!("Goki.toml already exists in workspace")
+pub fn process(path: &Path) -> Result<()> {
+    let maybe_cfg = Config::discover()?;
+    let cfg = if let Some(cfg) = maybe_cfg {
+        println!("Goki.toml already exists in workspace");
+        cfg.into_inner()
     } else {
         let cfg = Config::default();
         let mut file = File::create("Goki.toml")?;
         file.write_all(cfg.to_string().as_bytes())?;
-    }
+        cfg
+    };
+
+    let workspace = &Workspace {
+        path: path.to_path_buf(),
+        cfg,
+    };
 
     fs::create_dir_all(workspace.deployer_dir())?;