wip: redo everything?

Author: hansl

dfx/src/commands/call.rs

@@ -1,4 +1,4 @@
-use crate::lib::api_client::*;
+use crate::lib::api_client::Blob;
 use crate::lib::env::ClientEnv;
 use crate::lib::error::{DfxError, DfxResult};
 use clap::{App, Arg, ArgMatches, SubCommand};
@@ -30,31 +30,25 @@ where
     let name = args.value_of(NAME_ARG).unwrap();
     let client = env.get_client();
 
-    let query = query(
-        client,
-        CanisterQueryCall {
-            canister_id: 42,
-            method_name: "greet".to_string(),
-            arg: Blob(Vec::from(name)),
-        },
-    )
-    .and_then(|r| match r {
-        ReadResponse::Pending => {
-            println!("Pending");
-            ok(())
-        }
-        ReadResponse::Replied {
-            reply: QueryResponseReply { arg: Blob(blob) },
-        } => {
-            println!("{}", String::from_utf8_lossy(&blob));
-            ok(())
-        }
-        ReadResponse::Rejected {
-            reject_code,
-            reject_message,
-        } => err(DfxError::ClientError(reject_code, reject_message)),
-        ReadResponse::Unknown => err(DfxError::Unknown("Unknown response".to_owned())),
-    });
+    let query = client
+        .query(42, "greet".to_string(), Blob(Vec::from(name)))
+        .and_then(|r| match r {
+            ReadResponse::Pending => {
+                println!("Pending");
+                ok(())
+            }
+            ReadResponse::Replied {
+                reply: QueryResponseReply { arg: Blob(blob) },
+            } => {
+                println!("{}", String::from_utf8_lossy(&blob));
+                ok(())
+            }
+            ReadResponse::Rejected {
+                reject_code,
+                reject_message,
+            } => err(DfxError::ClientError(reject_code, reject_message)),
+            ReadResponse::Unknown => err(DfxError::Unknown("Unknown response".to_owned())),
+        });
 
     let mut runtime = Runtime::new().expect("Unable to create a runtime");
     runtime.block_on(query)

dfx/src/commands/canister/install.rs

@@ -1,9 +1,9 @@
-use crate::lib::api_client::{install_code, Blob, Client, ClientConfig};
+//use crate::lib::api_client::{install_code, Blob, Client};
 use crate::lib::env::{ClientEnv, ProjectConfigEnv};
 use crate::lib::error::DfxResult;
 use clap::{App, Arg, ArgMatches, SubCommand};
-use std::path::PathBuf;
-use tokio::runtime::Runtime;
+//use std::path::PathBuf;
+//use tokio::runtime::Runtime;
 
 fn is_number(v: String) -> Result<(), String> {
     v.parse::<u64>()
@@ -32,24 +32,24 @@ pub fn exec<T>(env: &T, args: &ArgMatches<'_>) -> DfxResult
 where
     T: ClientEnv + ProjectConfigEnv,
 {
-    // Read the config.
-    let config = env.get_config().unwrap();
-    let project_root = config.get_path().parent().unwrap();
-
-    let canister_id = args.value_of("canister").unwrap().parse::<u64>()?;
-    let url = "http://localhost:8080";
-    let wasm_path = args.value_of("wasm").unwrap();
-    let wasm_path = PathBuf::from(project_root).join(wasm_path);
-
-    let wasm = std::fs::read(wasm_path)?;
-    let client = Client::new(ClientConfig {
-        url: url.to_string(),
-    });
-
-    let install = install_code(client, canister_id, Blob(wasm), None);
-
-    let mut runtime = Runtime::new().expect("Unable to create a runtime");
-    runtime.block_on(install)?;
-
+    //    // Read the config.
+    //    let config = env.get_config().unwrap();
+    //    let project_root = config.get_path().parent().unwrap();
+    //
+    //    let canister_id = args.value_of("canister").unwrap().parse::<u64>()?;
+    //    let url = "http://localhost:8080";
+    //    let wasm_path = args.value_of("wasm").unwrap();
+    //    let wasm_path = PathBuf::from(project_root).join(wasm_path);
+    //
+    //    let wasm = std::fs::read(wasm_path)?;
+    //    let client = Client::new(ClientConfig {
+    //        url: url.to_string(),
+    //    });
+    //
+    //    let install = install_code(client, canister_id, Blob(wasm), None);
+    //
+    //    let mut runtime = Runtime::new().expect("Unable to create a runtime");
+    //    runtime.block_on(install)?;
+    //
     Ok(())
 }

dfx/src/commands/start.rs

@@ -1,8 +1,8 @@
-use crate::lib::api_client::{ping, Client, ClientConfig};
-use crate::lib::env::BinaryResolverEnv;
+use crate::lib::env::{BinaryResolverEnv, ClientEnv};
 use crate::lib::error::{DfxError, DfxResult};
 use clap::{App, Arg, ArgMatches, SubCommand};
 use indicatif::{ProgressBar, ProgressDrawTarget};
+use std::net::SocketAddr;
 use std::time::{Duration, Instant};
 use tokio::prelude::FutureExt;
 use tokio::runtime::Runtime;
@@ -22,7 +22,7 @@ pub fn construct() -> App<'static, 'static> {
 
 pub fn exec<T>(env: &T, args: &ArgMatches<'_>) -> DfxResult
 where
-    T: BinaryResolverEnv,
+    T: ClientEnv + BinaryResolverEnv,
 {
     let b = ProgressBar::new_spinner();
     b.set_draw_target(ProgressDrawTarget::stderr());
@@ -46,14 +46,13 @@ where
     let url = String::from(args.value_of("host").unwrap_or("http://localhost:8080"));
 
     let mut runtime = Runtime::new().expect("Unable to create a runtime");
+    let client = env.get_client(url);
 
     // Try to ping for 1 second, then timeout after 5 seconds if ping hasn't succeeded.
     let start = Instant::now();
     while {
-        let client = Client::new(ClientConfig { url: url.clone() });
-
         runtime
-            .block_on(ping(client).timeout(Duration::from_millis(TIMEOUT_IN_SECS * 1000 / 4)))
+            .block_on(client.ping().timeout(Duration::from_secs(1)))
             .is_err()
     } {
         if Instant::now().duration_since(start) > Duration::from_secs(TIMEOUT_IN_SECS) {