First Public Spec library draft and Request ID calculation in Rust

Cargo.toml

@@ -1,11 +1,8 @@
-[root]
-name = "dfinity-sdk"
-version = "0.2.1"
-
 [workspace]
 members = [
     "dfx",
     "lib/dfx_derive",
     "lib/dfx_info",
+    "lib/ic_http_agent",
     "lib/serde_idl"
 ]

dfx/Cargo.toml

@@ -21,6 +21,8 @@ clap = "2.33.0"
 console = "0.7.7"
 flate2 = "1.0.11"
 futures = "0.1.28"
+hex = "0.3.2"
+ic-http-agent = { "path" = "../lib/ic_http_agent" }
 indicatif = "0.12.0"
 rand = "0.7.2"
 reqwest = "0.9.20"

dfx/src/commands/canister/call.rs

@@ -1,9 +1,9 @@
-use crate::lib::api_client::{call, Blob};
+use crate::lib::api_client::{call, request_status, QueryResponseReply, ReadResponse};
 use crate::lib::env::ClientEnv;
-use crate::lib::error::DfxResult;
-use crate::lib::CanisterId;
+use crate::lib::error::{DfxError, DfxResult};
 use crate::util::clap::validators;
 use clap::{App, Arg, ArgMatches, SubCommand};
+use ic_http_agent::{Blob, CanisterId};
 use tokio::runtime::Runtime;
 
 pub fn construct() -> App<'static, 'static> {
@@ -21,6 +21,13 @@ pub fn construct() -> App<'static, 'static> {
                 .help("The method name file to use.")
                 .required(true),
         )
+        .arg(
+            Arg::with_name("wait")
+                .help("Wait for the result of the call, by polling the client.")
+                .long("wait")
+                .short("w")
+                .takes_value(false),
+        )
         .arg(
             Arg::with_name("arguments")
                 .help("Arguments to pass to the method.")
@@ -47,7 +54,32 @@ where
     );
 
     let mut runtime = Runtime::new().expect("Unable to create a runtime");
-    runtime.block_on(install)?;
+    let request_id = runtime.block_on(install)?;
 
-    Ok(())
+    if args.is_present("wait") {
+        let request_status = request_status(env.get_client(), request_id);
+        let mut runtime = Runtime::new().expect("Unable to create a runtime");
+        match runtime.block_on(request_status) {
+            Ok(ReadResponse::Pending) => {
+                println!("Pending");
+                Ok(())
+            }
+            Ok(ReadResponse::Replied { reply }) => {
+                if let Some(QueryResponseReply { arg: Blob(blob) }) = reply {
+                    println!("{}", String::from_utf8_lossy(&blob));
+                }
+                Ok(())
+            }
+            Ok(ReadResponse::Rejected {
+                reject_code,
+                reject_message,
+            }) => Err(DfxError::ClientError(reject_code, reject_message)),
+            // TODO(SDK-446): remove this when moving api_client to ic_http_agent.
+            Ok(ReadResponse::Unknown) => Err(DfxError::Unknown("Unknown response".to_owned())),
+            Err(x) => Err(x),
+        }
+    } else {
+        println!("0x{}", String::from(request_id));
+        Ok(())
+    }
 }

dfx/src/commands/canister/install.rs

@@ -1,9 +1,9 @@
-use crate::lib::api_client::{install_code, Blob};
+use crate::lib::api_client::install_code;
 use crate::lib::env::{ClientEnv, ProjectConfigEnv};
 use crate::lib::error::DfxResult;
-use crate::lib::CanisterId;
 use crate::util::clap::validators;
 use clap::{App, Arg, ArgMatches, SubCommand};
+use ic_http_agent::{Blob, CanisterId};
 use std::path::PathBuf;
 use tokio::runtime::Runtime;
 

dfx/src/commands/canister/mod.rs

@@ -6,6 +6,7 @@ use clap::{App, ArgMatches, SubCommand};
 mod call;
 mod install;
 mod query;
+mod request_status;
 
 fn builtins<T>() -> Vec<CliCommand<T>>
 where
@@ -15,6 +16,7 @@ where
         CliCommand::new(call::construct(), call::exec),
         CliCommand::new(install::construct(), install::exec),
         CliCommand::new(query::construct(), query::exec),
+        CliCommand::new(request_status::construct(), request_status::exec),
     ]
 }
 

dfx/src/commands/canister/query.rs

@@ -1,9 +1,9 @@
-use crate::lib::api_client::{query, Blob, QueryResponseReply, ReadResponse};
+use crate::lib::api_client::{query, QueryResponseReply, ReadResponse};
 use crate::lib::env::ClientEnv;
 use crate::lib::error::{DfxError, DfxResult};
-use crate::lib::CanisterId;
 use crate::util::clap::validators;
 use clap::{App, Arg, ArgMatches, SubCommand};
+use ic_http_agent::{Blob, CanisterId};
 use tokio::runtime::Runtime;
 
 pub fn construct() -> App<'static, 'static> {
@@ -52,17 +52,17 @@ where
             println!("Pending");
             Ok(())
         }
-        Ok(ReadResponse::Replied {
-            reply: QueryResponseReply { arg: Blob(blob) },
-        }) => {
-            println!("{}", String::from_utf8_lossy(&blob));
+        Ok(ReadResponse::Replied { reply }) => {
+            if let Some(QueryResponseReply { arg: Blob(blob) }) = reply {
+                println!("{}", String::from_utf8_lossy(&blob));
+            }
             Ok(())
         }
         Ok(ReadResponse::Rejected {
             reject_code,
             reject_message,
         }) => Err(DfxError::ClientError(reject_code, reject_message)),
-        // TODO: remove this when moving to ic_http_api.
+        // TODO(SDK-446): remove this when moving api_client to ic_http_agent.
         Ok(ReadResponse::Unknown) => Err(DfxError::Unknown("Unknown response".to_owned())),
         Err(x) => Err(x),
     }

dfx/src/commands/canister/request_status.rs

@@ -0,0 +1,48 @@
+use crate::lib::api_client::{request_status, QueryResponseReply, ReadResponse};
+use crate::lib::env::ClientEnv;
+use crate::lib::error::{DfxError, DfxResult};
+use crate::util::clap::validators;
+use clap::{App, Arg, ArgMatches, SubCommand};
+use ic_http_agent::{Blob, RequestId};
+use std::str::FromStr;
+use tokio::runtime::Runtime;
+
+pub fn construct() -> App<'static, 'static> {
+    SubCommand::with_name("request-status")
+        .about("Request the status of a call to a canister.")
+        .arg(
+            Arg::with_name("request_id")
+                .takes_value(true)
+                .help("The request ID to call. This is an hexadecimal string starting with 0x.")
+                .required(true)
+                .validator(validators::is_request_id),
+        )
+}
+
+pub fn exec<T>(env: &T, args: &ArgMatches<'_>) -> DfxResult
+where
+    T: ClientEnv,
+{
+    let request_id = RequestId::from_str(&args.value_of("request_id").unwrap()[2..])?;
+    let request_status = request_status(env.get_client(), request_id);
+    let mut runtime = Runtime::new().expect("Unable to create a runtime");
+    match runtime.block_on(request_status) {
+        Ok(ReadResponse::Pending) => {
+            println!("Pending");
+            Ok(())
+        }
+        Ok(ReadResponse::Replied { reply }) => {
+            if let Some(QueryResponseReply { arg: Blob(blob) }) = reply {
+                println!("{}", String::from_utf8_lossy(&blob));
+            }
+            Ok(())
+        }
+        Ok(ReadResponse::Rejected {
+            reject_code,
+            reject_message,
+        }) => Err(DfxError::ClientError(reject_code, reject_message)),
+        // TODO(SDK-446): remove this when moving api_client to ic_http_agent.
+        Ok(ReadResponse::Unknown) => Err(DfxError::Unknown("Unknown response".to_owned())),
+        Err(x) => Err(x),
+    }
+}

dfx/src/commands/new.rs

@@ -97,7 +97,6 @@ where
     b.set_message("Looking for latest version...");
     b.enable_steady_tick(80);
 
-    std::thread::sleep(std::time::Duration::from_secs(1));
     if !env.is_installed()? {
         env.install()?;
         b.finish_with_message(