feat: dfx deploy command

e2e/bats/assets/transitive_deps_canisters/dfx.json

@@ -23,6 +23,21 @@
       "dependencies": ["canister_d"],
       "main": "./e/main.mo",
       "type": "motoko"
+    },
+    "canister_f": {
+      "dependencies": ["canister_g", "canister_h"],
+      "main": "./f/main.mo",
+      "type": "motoko"
+    },
+    "canister_g": {
+      "dependencies": ["canister_a"],
+      "main": "./g/main.mo",
+      "type": "motoko"
+    },
+    "canister_h": {
+      "dependencies": ["canister_a"],
+      "main": "./h/main.mo",
+      "type": "motoko"
     }
   },
   "defaults": {

e2e/bats/assets/transitive_deps_canisters/f/main.mo

@@ -0,0 +1,5 @@
+actor {
+    public func greet(name : Text) : async Text {
+        return "Bună, " # name # "!";
+    };
+};

e2e/bats/assets/transitive_deps_canisters/g/main.mo

@@ -0,0 +1,5 @@
+actor {
+    public func greet(name : Text) : async Text {
+        return "Ciao, " # name # "!";
+    };
+};

e2e/bats/assets/transitive_deps_canisters/h/main.mo

@@ -0,0 +1,5 @@
+actor {
+    public func greet(name : Text) : async Text {
+        return "Olá, " # name # "!";
+    };
+};

e2e/bats/build_granular.bash

@@ -77,8 +77,15 @@ teardown() {
     install_asset transitive_deps_canisters
     dfx_start
     dfx canister create --all
-    assert_command dfx build canister_e
-    assert_match "Possible circular dependency detected during evaluation of canister_d's dependency on canister_e."
+    assert_command_fail dfx build canister_e
+    assert_match " There is a dependency cycle between canisters found at canister canister_e -> canister_d -> canister_e"
+}
+
+@test "multiple non-cyclic dependency paths to the same canister are ok" {
+    install_asset transitive_deps_canisters
+    dfx_start
+    dfx canister create --all
+    assert_command dfx build canister_f
 }
 
 @test "the all flag builds everything" {

e2e/bats/deploy.bash

@@ -0,0 +1,58 @@
+#!/usr/bin/env bats
+
+load utils/_
+
+setup() {
+    # We want to work from a temporary directory, different for every test.
+    cd $(mktemp -d -t dfx-e2e-XXXXXXXX)
+    export RUST_BACKTRACE=1
+
+    dfx_new hello
+    dfx_start
+}
+
+teardown() {
+  dfx_stop
+}
+
+@test "deploy from a fresh project" {
+    install_asset greet
+    assert_command dfx deploy
+
+    assert_command dfx canister call hello greet '("Banzai")'
+    assert_eq '("Hello, Banzai!")'
+}
+
+@test "deploy a canister without dependencies" {
+    install_asset greet
+    assert_command dfx deploy hello
+    assert_match 'Deploying: hello'
+    assert_not_match 'hello_assets'
+}
+
+@test "deploy a canister with dependencies" {
+    install_asset greet
+    assert_command dfx deploy hello_assets
+    assert_match 'Deploying: hello hello_assets'
+}
+
+@test "deploy a canister with non-circular shared dependencies" {
+    install_asset transitive_deps_canisters
+    assert_command dfx deploy canister_f
+    assert_match 'Deploying: canister_a canister_f canister_g canister_h'
+}
+
+@test "report an error on attempt to deploy a canister with circular dependencies" {
+    install_asset transitive_deps_canisters
+    assert_command_fail dfx deploy canister_d
+    assert_match 'canister_d -> canister_e -> canister_d'
+}
+
+@test "if already registered, try to upgrade then install" {
+    install_asset greet
+    assert_command dfx canister create --all
+
+    assert_command dfx deploy
+    assert_match 'attempting install'
+}
+

e2e/bats/utils/assertions.bash

@@ -70,6 +70,25 @@ assert_match() {
          | fail)
 }
 
+# Asserts that a string does not contain another string, using regexp.
+# Arguments:
+#    $1 - The regex to use to match.
+#    $2 - The string to match against (output). By default it will use
+#         $output.
+assert_not_match() {
+    regex="$1"
+    if [[ $# < 2 ]]; then
+        text="$output"
+    else
+        text="$2"
+    fi
+    if [[ "$text" =~ $regex ]]; then
+        (batslib_print_kv_single_or_multi 10 "regex" "$regex" "actual" "$text" \
+         | batslib_decorate "output matches but is expected not to" \
+         | fail)
+    fi
+}
+
 # Asserts a command will timeout. This assertion will fail if the command finishes before
 # the timeout period. If the command fails, it will also fail.
 # Arguments:

src/dfx/src/commands/build.rs

@@ -56,9 +56,12 @@ pub fn exec(env: &dyn Environment, args: &ArgMatches<'_>) -> DfxResult {
 
     // Option can be None in which case --all was specified
     let some_canister = args.value_of("canister_name");
+    let canister_names = config
+        .get_config()
+        .get_canister_names_with_dependencies(some_canister)?;
 
     // Get pool of canisters to build
-    let canister_pool = CanisterPool::load(&env, build_mode_check, some_canister)?;
+    let canister_pool = CanisterPool::load(&env, build_mode_check, &canister_names)?;
 
     // Create canisters on the replica and associate canister ids locally.
     if args.is_present("check") {

src/dfx/src/commands/deploy.rs

@@ -0,0 +1,31 @@
+use crate::lib::environment::Environment;
+use crate::lib::error::DfxResult;
+use crate::lib::message::UserMessage;
+use crate::lib::operations::canister::deploy_canisters;
+use crate::lib::provider::create_agent_environment;
+use clap::{App, Arg, ArgMatches, SubCommand};
+
+pub fn construct() -> App<'static, 'static> {
+    SubCommand::with_name("deploy")
+        .about(UserMessage::DeployCanister.to_str())
+        .arg(
+            Arg::with_name("canister_name")
+                .takes_value(true)
+                .help(UserMessage::DeployCanisterName.to_str())
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("network")
+                .help(UserMessage::CanisterComputeNetwork.to_str())
+                .long("network")
+                .takes_value(true),
+        )
+}
+
+pub fn exec(env: &dyn Environment, args: &ArgMatches<'_>) -> DfxResult {
+    let env = create_agent_environment(env, args)?;
+
+    let canister = args.value_of("canister_name");
+
+    deploy_canisters(&env, canister)
+}

src/dfx/src/commands/mod.rs

@@ -7,6 +7,7 @@ mod build;
 mod cache;
 mod canister;
 mod config;
+mod deploy;
 mod identity;
 mod language_service;
 mod new;
@@ -48,6 +49,7 @@ pub fn builtin() -> Vec<CliCommand> {
         CliCommand::new(cache::construct(), cache::exec),
         CliCommand::new(canister::construct(), canister::exec),
         CliCommand::new(config::construct(), config::exec),
+        CliCommand::new(deploy::construct(), deploy::exec),
         CliCommand::new(identity::construct(), identity::exec),
         CliCommand::new(language_service::construct(), language_service::exec),
         CliCommand::new(new::construct(), new::exec),

src/dfx/src/config/dfinity.rs

@@ -1,9 +1,9 @@
 #![allow(dead_code)]
 
-use crate::lib::error::{DfxError, DfxResult};
+use crate::lib::error::{BuildErrorKind, DfxError, DfxResult};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashSet};
 use std::default::Default;
 use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
 use std::path::{Path, PathBuf};
@@ -238,6 +238,72 @@ impl ConfigInterface {
     pub fn get_dfx(&self) -> Option<String> {
         self.dfx.to_owned()
     }
+
+    /// Return the names of the specified canister and all of its dependencies.
+    /// If none specified, return the names of all canisters.
+    pub fn get_canister_names_with_dependencies(
+        &self,
+        some_canister: Option<&str>,
+    ) -> DfxResult<Vec<String>> {
+        let canister_map = (&self.canisters).as_ref().ok_or_else(|| {
+            DfxError::InvalidConfiguration("No canisters in the configuration file.".to_string())
+        })?;
+
+        let canister_names = match some_canister {
+            Some(specific_canister) => {
+                let mut names = HashSet::new();
+                let mut path = vec![];
+                add_dependencies(canister_map, &mut names, &mut path, specific_canister)?;
+                names.into_iter().collect()
+            }
+            None => canister_map.keys().cloned().collect(),
+        };
+
+        Ok(canister_names)
+    }
+}
+
+fn add_dependencies(
+    all_canisters: &BTreeMap<String, ConfigCanistersCanister>,
+    names: &mut HashSet<String>,
+    path: &mut Vec<String>,
+    canister_name: &str,
+) -> DfxResult {
+    let inserted = names.insert(String::from(canister_name));
+
+    if !inserted {
+        return if path.contains(&String::from(canister_name)) {
+            path.push(String::from(canister_name));
+            Err(DfxError::BuildError(BuildErrorKind::CircularDependency(
+                path.join(" -> "),
+            )))
+        } else {
+            Ok(())
+        };
+    }
+
+    let canister_config = all_canisters
+        .get(canister_name)
+        .ok_or_else(|| DfxError::CannotFindCanisterName(canister_name.to_string()))?;
+
+    let deps = match canister_config.extras.get("dependencies") {
+        None => vec![],
+        Some(v) => Vec::<String>::deserialize(v).map_err(|_| {
+            DfxError::InvalidConfiguration(String::from(
+                "Field 'dependencies' is of the wrong type",
+            ))
+        })?,
+    };
+
+    path.push(String::from(canister_name));
+
+    for canister in deps {
+        add_dependencies(all_canisters, names, path, &canister)?;
+    }
+
+    path.pop();
+
+    Ok(())
 }
 
 #[derive(Clone)]

src/dfx/src/lib/error/mod.rs

@@ -69,7 +69,6 @@ pub enum DfxError {
     /// Argument provided is invalid.
     InvalidArgument(String),
 
-    #[allow(dead_code)]
     /// Configuration provided is invalid.
     InvalidConfiguration(String),
     /// Method called invalid.
@@ -198,6 +197,9 @@ impl Display for DfxError {
             DfxError::InvalidArgument(e) => {
                 f.write_fmt(format_args!("Invalid argument: {}", e))?;
             }
+            DfxError::InvalidConfiguration(e) => {
+                f.write_fmt(format_args!("Invalid configuration: {}", e))?;
+            }
             DfxError::InvalidData(e) => {
                 f.write_fmt(format_args!("Invalid data: {}", e))?;
             }

src/dfx/src/lib/message.rs

@@ -98,7 +98,11 @@ user_message!(
     ConfigureOptions => "Configures project options for your currently-selected project.",
     OptionName => "Specifies the name of the configuration option to set or read. Use the period delineated path to specify the option to set or read. If this is not mentioned, outputs the whole configuration.",
     OptionValue => "Specifies the new value to set. If you don't specify a value, the command displays the current value of the option from the configuration file.",
-    OptionFormat => "Specifies the format of the output. By default, it uses JSON.",
+    OptionFormat => "Specifies the format of the output. By default, the output format is JSON.",
+
+    // dfx deploy
+    DeployCanister => "Deploys all or a specific canister from the code in your project. By default, all canisters are deployed.",
+    DeployCanisterName => "Specifies the name of the canister you want to deploy. If you don’t specify a canister name, all canisters defined in the dfx.json file are deployed.",
 
     // dfx identity mod
     ManageIdentity => "Manages identities used to communicate with the Internet Computer network. Setting an identity enables you to test user-based access controls.",