Add tokio as async runtime

- converting methods to be async
- remove `Cmd` trait, because it is tedious with async and it was not
  so much useful anyways

Cargo.toml

@@ -24,6 +24,8 @@ reqwest = { version = "0.12.5", default-features = false, features = ["json", "b
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.118"
 snafu = { version = "0.8.3" }
+tokio = { version = "1", features = ["full"] }
+futures = { version = "0.3" }
 
 [features]
 default = ["reqwest/default-tls"] # link against system library

src/cli.rs

@@ -2,23 +2,23 @@ pub mod cmd;
 pub mod opts;
 pub mod sink;
 
-use self::cmd::{Cmd, CmdError, Context};
+use self::cmd::{CmdError, Context};
 use self::opts::{MainOpts, SubCommand};
 use clap::CommandFactory;
 use serde::Serialize;
 use std::fmt;
 
-pub fn execute_cmd(opts: MainOpts) -> Result<(), CmdError> {
+pub async fn execute_cmd(opts: MainOpts) -> Result<(), CmdError> {
     let ctx = Context::new(&opts.common_opts)?;
 
     log::info!("Running command: {:?}", opts.subcmd);
     match &opts.subcmd {
-        SubCommand::Version(input) => input.exec(&ctx)?,
+        SubCommand::Version(input) => input.exec(&ctx).await?,
         SubCommand::ShellCompletion(input) => {
             let mut app = MainOpts::command();
-            input.print_completions(&mut app);
+            input.print_completions(&mut app).await;
         }
-        SubCommand::Project(input) => input.exec(&ctx)?,
+        SubCommand::Project(input) => input.exec(&ctx).await?,
     };
     Ok(())
 }

src/cli/cmd.rs

@@ -8,20 +8,14 @@ use crate::httpclient::{self, proxy, Client};
 use serde::Serialize;
 use snafu::{ResultExt, Snafu};
 
-pub trait Cmd {
-    type CmdError;
-
-    fn exec(&self, args: &Context) -> Result<(), Self::CmdError>;
-}
+const RENKULAB_IO: &str = "https://renkulab.io";
 
 pub struct Context<'a> {
     pub opts: &'a CommonOpts,
     pub client: Client,
     pub renku_url: String,
 }
 
-const RENKULABIO: &str = "https://renkulab.io";
-
 impl Context<'_> {
     pub fn new(opts: &CommonOpts) -> Result<Context, CmdError> {
         let base_url = get_renku_url(opts);
@@ -35,7 +29,7 @@ impl Context<'_> {
     }
 
     /// A short hand for `Sink::write(self.format(), value)`
-    fn write_result<A: Sink + Serialize>(&self, value: A) -> Result<(), SinkError> {
+    async fn write_result<A: Sink + Serialize>(&self, value: A) -> Result<(), SinkError> {
         let fmt = self.format();
         Sink::write(fmt, &value)
     }
@@ -58,7 +52,7 @@ fn get_renku_url(opts: &CommonOpts) -> String {
             }
             None => {
                 log::debug!("Use renku url: https://renkulab.io");
-                RENKULABIO.to_string()
+                RENKULAB_IO.to_string()
             }
         },
     }

src/cli/cmd/project.rs

@@ -1,6 +1,6 @@
 pub mod clone;
 
-use super::{Cmd, Context};
+use super::Context;
 use clap::Parser;
 use snafu::{ResultExt, Snafu};
 
@@ -16,12 +16,10 @@ pub struct Input {
     pub subcmd: ProjectCommand,
 }
 
-impl Cmd for Input {
-    type CmdError = Error;
-
-    fn exec(&self, ctx: &Context) -> Result<(), Error> {
+impl Input {
+    pub async fn exec<'a>(&self, ctx: &Context<'a>) -> Result<(), Error> {
         match &self.subcmd {
-            ProjectCommand::Clone(input) => input.exec(ctx).context(CloneSnafu),
+            ProjectCommand::Clone(input) => input.exec(ctx).await.context(CloneSnafu),
         }
     }
 }

src/cli/cmd/project/clone.rs

@@ -1,4 +1,4 @@
-use super::{Cmd, Context};
+use super::Context;
 
 use clap::Parser;
 use snafu::Snafu;
@@ -10,10 +10,8 @@ pub struct Input {
     pub slug: String,
 }
 
-impl Cmd for Input {
-    type CmdError = Error;
-
-    fn exec(&self, _ctx: &Context) -> Result<(), Error> {
+impl Input {
+    pub async fn exec<'a>(&self, _ctx: &Context<'a>) -> Result<(), Error> {
         Ok(())
     }
 }

src/cli/cmd/shell_completion.rs

@@ -25,7 +25,7 @@ pub enum GeneratorChoice {
 }
 
 impl Input {
-    pub fn print_completions(&self, app: &mut Command) {
+    pub async fn print_completions(&self, app: &mut Command) {
         let binary = &self.binary;
         match &self.shell {
             GeneratorChoice::Bash => generate_completions(Shell::Bash, binary, app),

src/cli/cmd/version.rs

@@ -1,4 +1,4 @@
-use super::{Cmd, Context};
+use super::Context;
 use crate::cli::sink::Error as SinkError;
 use crate::cli::sink::Sink;
 use crate::cli::BuildInfo;
@@ -25,16 +25,15 @@ pub enum Error {
     WriteResult { source: SinkError },
 }
 
-impl Cmd for Input {
-    type CmdError = Error;
-
-    fn exec(&self, ctx: &Context) -> Result<(), Error> {
+impl Input {
+    pub async fn exec<'a>(&self, ctx: &Context<'a>) -> Result<(), Error> {
         let result = ctx
             .client
             .version(ctx.opts.verbose > 1)
+            .await
             .context(HttpClientSnafu)?;
         let vinfo = Versions::create(result, &ctx.renku_url);
-        ctx.write_result(vinfo).context(WriteResultSnafu)?;
+        ctx.write_result(vinfo).await.context(WriteResultSnafu)?;
         Ok(())
     }
 }