feat: Make integration

.gitignore

@@ -32,3 +32,4 @@ advisory-db/
 
 # mops
 **/.mops/
+.qodo

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 # UNRELEASED
 
+* Flags `--no-compile` and `--no-deps`
+
+* Command `rules` that outputs time-efficient GNU Make rules.
+
 ### fix: deps deploy works with Canister ID out of the ranges of the pocket-ic subnets
 
 The `dfx deps deploy` command didn't work when the pulled dependency's Canister ID is out of the ranges of the `pocket-ic` subnets.
@@ -99,6 +103,7 @@ This incorporates the following executed proposals:
 dfx would try to reuse canister ids when switching from a shared network to a project network,
 which would cause errors since those canister ids wouldn't exist. dfx now deletes the .dfx
 directory if it was previously used with the shared local network.
+>>>>>>> upstream/master
 
 ### feat: Set canister ids using `dfx canister set-id <canister name> <principal>`
 

docs/cli-reference/dfx-build.mdx

@@ -20,9 +20,10 @@ dfx build [flag] [option] [--all | canister_name]
 
 You can use the following optional flags with the `dfx build` command.
 
-| Flag      | Description                                                                                                                                              |
-| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--check` | Builds canisters using a temporary, hard-coded, locally-defined canister ID for testing that the canister compiles without connecting to ICP. |
+| Flag        | Description                                                                                                                                              |
+| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--check`   | Builds canisters using a temporary, hard-coded, locally-defined canister ID for testing that the canister compiles without connecting to ICP.            |
+| `--no-deps` | Don't build dependencies, only this canister.                                                                                                            |
 
 ## Options
 

docs/cli-reference/dfx-deploy.mdx

@@ -46,6 +46,7 @@ You can use the following options with the `dfx deploy` command.
 | `--next-to <canister-principal>`   | Create canisters on the same subnet as this canister.                                                                                                                                                                                                              |
 | `--skip-pre-upgrade`               | Skip the `pre_upgrade` hook on upgrade. This requires the upgrade/auto mode.                                                                                                                                                                                         |
 | `--wasm-memory-persistence <mode>` | Keep or replace the Wasm main memory on upgrade. Possible values: keep, replace. This requires the upgrade/auto mode.                                                                                                                                              |
+| `--no-compile`                     | Don't compile before deploying.                                                                                                                                                                                                                                    |
 
 ### Specifies the argument to pass to the init entrypoint
 

docs/cli-reference/dfx-generate.mdx

@@ -18,6 +18,14 @@ The `dfx generate` command looks for the configuration under the `declarations`
 dfx generate [canister_name]
 ```
 
+## Options
+
+You can use the following options with the `dfx deploy` command.
+
+| Argument       | Description                                               |
+|----------------|-----------------------------------------------------------|
+| `--no-compile` | Don't compile the canister(s) before generating bindings. |
+
 ## Arguments
 
 You can specify the following arguments for the `dfx generate` command.

docs/cli-reference/dfx-rules.mdx

@@ -0,0 +1,28 @@
+import { MarkdownChipRow } from "/src/components/Chip/MarkdownChipRow";
+
+# dfx rules
+
+<MarkdownChipRow labels={["Reference"]} />
+
+**Warning:** This is an experimental feature.
+
+Use the `dfx rules` command to output GNU Make rules for efficient compilation of canisters.
+
+The rules, that can be used:
+* `canister@NAME` - compile a canister.
+* `deploy@NAME` - deploy a canister.
+* `generate@NAME` - generate bindings for a canister.
+
+TODO
+
+## Basic usage
+
+``` bash
+dfx rules [-o MAKEFILE]
+```
+
+**Warning:** The MAKEFILE is overwritten by the above command.
+
+| Argument                     | Description                     |
+|------------------------------|---------------------------------|
+| `-o FILE` or `--output FILE` | Use this file instead of stdout |

src/dfx/assets/prepare_assets.rs

@@ -146,13 +146,13 @@ fn write_binary_cache(
 async fn download_and_check_sha(client: Client, source: Source) -> Bytes {
     let retry_policy = ExponentialBackoffBuilder::new()
         .with_initial_interval(Duration::from_secs(1))
-        .with_max_interval(Duration::from_secs(16))
-        .with_multiplier(2.0)
-        .with_max_elapsed_time(Some(Duration::from_secs(300)))
+        .with_max_interval(Duration::from_secs(64))
+        .with_multiplier(1.5)
+        .with_max_elapsed_time(Some(Duration::from_secs(3600)))
         .build();
 
     let response = retry(retry_policy, || async {
-        match client.get(&source.url).send().await {
+        match client.get(&source.url).timeout(Duration::from_secs(3600)).send().await {
             Ok(response) => Ok(response),
             Err(err) => Err(backoff::Error::transient(err)),
         }

src/dfx/src/commands/build.rs

@@ -25,6 +25,10 @@ pub struct CanisterBuildOpts {
     #[arg(long)]
     check: bool,
 
+    /// Don't compile the dependencies, only this canister.
+    #[arg(long)]
+    no_deps: bool,
+
     /// Output environment variables to a file in dotenv format (without overwriting any user-defined variables, if the file already exists).
     #[arg(long)]
     output_env_file: Option<PathBuf>,
@@ -48,10 +52,21 @@ pub fn exec(env: &dyn Environment, opts: CanisterBuildOpts) -> DfxResult {
 
     let build_mode_check = opts.check;
 
-    // Option can be None in which case --all was specified
-    let required_canisters = config
-        .get_config()
-        .get_canister_names_with_dependencies(opts.canister_name.as_deref())?;
+    let required_canisters = if opts.no_deps {
+        // Option can be None in which case --all was specified
+        let canister = opts.canister_name.as_deref();
+        match canister {
+            Some(canister) => vec![canister.to_string()],
+            // inefficient:
+            None => config
+                .get_config()
+                .get_canister_names_with_dependencies(None)?
+        }
+    } else {
+        config
+            .get_config()
+            .get_canister_names_with_dependencies(opts.canister_name.as_deref())?
+    };
     let canisters_to_load = add_canisters_with_ids(&required_canisters, &env, &config);
 
     let canisters_to_build = required_canisters
@@ -86,7 +101,7 @@ pub fn exec(env: &dyn Environment, opts: CanisterBuildOpts) -> DfxResult {
     let build_config = BuildConfig::from_config(&config)?
         .with_canisters_to_build(canisters_to_build)
         .with_env_file(env_file);
-    runtime.block_on(canister_pool.build_or_fail(&env, logger, &build_config))?;
+    runtime.block_on(canister_pool.build_or_fail(&env, logger, &build_config, opts.no_deps))?;
 
     slog::info!(logger, "Finished building canisters.");
 

src/dfx/src/commands/deploy.rs

@@ -103,6 +103,10 @@ pub struct DeployOpts {
     #[command(flatten)]
     subnet_selection: SubnetSelectionOpt,
 
+    /// Skip compilation before deploying.
+    #[arg(long)]
+    no_compile: bool,
+
     /// Always use Candid assist when the argument types are all optional.
     #[arg(
         long,
@@ -183,6 +187,7 @@ pub fn exec(env: &dyn Environment, opts: DeployOpts) -> DfxResult {
         opts.no_asset_upgrade,
         &mut subnet_selection,
         opts.always_assist,
+        opts.no_compile,
     ))?;
 
     if matches!(deploy_mode, NormalDeploy | ForceReinstallSingleCanister(_)) {

src/dfx/src/commands/generate.rs

@@ -15,6 +15,10 @@ pub struct GenerateOpts {
     /// If you do not specify a canister name, generates types for all canisters.
     canister_name: Option<String>,
 
+    /// Don't compile Motoko before generating.
+    #[arg(long)]
+    no_compile: bool,
+
     #[command(flatten)]
     network: NetworkOpt,
 }
@@ -62,7 +66,7 @@ pub fn exec(env: &dyn Environment, opts: GenerateOpts) -> DfxResult {
     let generate_config =
         BuildConfig::from_config(&config)?.with_canisters_to_build(canisters_to_generate);
 
-    if build_config
+    if !opts.no_compile && build_config
         .canisters_to_build
         .as_ref()
         .map(|v| !v.is_empty())
@@ -71,7 +75,7 @@ pub fn exec(env: &dyn Environment, opts: GenerateOpts) -> DfxResult {
         let canister_pool_build = CanisterPool::load(&env, true, &build_dependees)?;
         let spinner = env.new_spinner("Building Motoko canisters before generation...".into());
         let runtime = Runtime::new().expect("Unable to create a runtime");
-        runtime.block_on(canister_pool_build.build_or_fail(&env, log, &build_config))?;
+        runtime.block_on(canister_pool_build.build_or_fail(&env, log, &build_config, opts.no_compile))?;
         spinner.finish_and_clear();
     }
 

src/dfx/src/commands/mod.rs

@@ -25,6 +25,7 @@ mod new;
 mod ping;
 mod quickstart;
 mod remote;
+mod rules;
 mod schema;
 mod send_telemetry;
 mod start;
@@ -57,6 +58,7 @@ pub enum DfxCommand {
     Ping(ping::PingOpts),
     Quickstart(quickstart::QuickstartOpts),
     Remote(remote::RemoteOpts),
+    Rules(rules::RulesOpts),
     Schema(schema::SchemaOpts),
     #[command(name = "_send-telemetry", hide = true)]
     SendTelemetry(send_telemetry::SendTelemetryOpts),
@@ -92,6 +94,7 @@ pub fn exec(env: &dyn Environment, cmd: DfxCommand) -> DfxResult {
         DfxCommand::Ping(v) => ping::exec(env, v),
         DfxCommand::Quickstart(v) => quickstart::exec(env, v),
         DfxCommand::Remote(v) => remote::exec(env, v),
+        DfxCommand::Rules(v) => rules::exec(env, v),
         DfxCommand::Schema(v) => schema::exec(v),
         DfxCommand::SendTelemetry(v) => send_telemetry::exec(v),
         DfxCommand::Start(v) => start::exec(env, v),