feat: add a --client flag to the canister

src/dfx/src/commands/canister/mod.rs

@@ -1,8 +1,8 @@
 use crate::commands::CliCommand;
-use crate::lib::environment::Environment;
+use crate::lib::environment::{ClientEnvironment, Environment};
 use crate::lib::error::{DfxError, DfxResult};
 use crate::lib::message::UserMessage;
-use clap::{App, ArgMatches, SubCommand};
+use clap::{App, Arg, ArgMatches, ArgSettings, SubCommand};
 
 mod call;
 mod install;
@@ -21,12 +21,36 @@ fn builtins() -> Vec<CliCommand> {
 pub fn construct() -> App<'static, 'static> {
     SubCommand::with_name("canister")
         .about(UserMessage::ManageCanister.to_str())
+        .arg(
+            Arg::with_name("client")
+                .set(ArgSettings::Global)
+                .help(UserMessage::CanisterClient.to_str())
+                .long("client")
+                .validator(|v| {
+                    reqwest::Url::parse(&v)
+                        .map(|_| ())
+                        .map_err(|_| "should be a valid URL.".to_string())
+                })
+                .takes_value(true),
+        )
         .subcommands(builtins().into_iter().map(|x| x.get_subcommand().clone()))
 }
 
 pub fn exec(env: &dyn Environment, args: &ArgMatches<'_>) -> DfxResult {
     let subcommand = args.subcommand();
 
+    // Need storage for ClientEnvironment ownership.
+    let mut _client_env: Option<ClientEnvironment<'_>> = None;
+    let env = if args.is_present("client") {
+        _client_env = Some(ClientEnvironment::new(
+            env,
+            args.value_of("client").expect("Could not find client."),
+        ));
+        _client_env.as_ref().unwrap()
+    } else {
+        env
+    };
+
     if let (name, Some(subcommand_args)) = subcommand {
         match builtins().into_iter().find(|x| name == x.get_name()) {
             Some(cmd) => cmd.execute(env, subcommand_args),

src/dfx/src/lib/environment.rs

@@ -116,3 +116,45 @@ impl Environment for EnvironmentImpl {
         self.get_client()
     }
 }
+
+pub struct ClientEnvironment<'a> {
+    backend: &'a dyn Environment,
+    client: Client,
+}
+
+impl<'a> ClientEnvironment<'a> {
+    pub fn new(backend: &'a dyn Environment, client_url: &str) -> Self {
+        ClientEnvironment {
+            backend,
+            client: Client::new(ClientConfig {
+                url: client_url.to_string(),
+            }),
+        }
+    }
+}
+
+impl<'a> Environment for ClientEnvironment<'a> {
+    fn get_cache(&self) -> Rc<dyn Cache> {
+        self.backend.get_cache()
+    }
+
+    fn get_config(&self) -> Option<Rc<Config>> {
+        self.backend.get_config()
+    }
+
+    fn is_in_project(&self) -> bool {
+        self.backend.is_in_project()
+    }
+
+    fn get_temp_dir(&self) -> &Path {
+        self.backend.get_temp_dir()
+    }
+
+    fn get_version(&self) -> &Version {
+        self.backend.get_version()
+    }
+
+    fn get_client(&self) -> Option<Client> {
+        Some(self.client.clone())
+    }
+}

src/dfx/src/lib/message.rs

@@ -39,6 +39,7 @@ user_message!(
 
     // dfx canister mod
     ManageCanister => "Manages canisters deployed on a network client.",
+    CanisterClient => "Override the client to connect to. By default uses the client set in dfx configuration.",
 
     // dfx canister query
     QueryCanister => "Sends a query request to a canister.",