add common incremental_create_execution_output_dir

Author: DelevoXDG

extensions/scarb-execute/src/lib.rs

@@ -19,6 +19,7 @@ use cairo_vm::{Felt252, cairo_run};
 use camino::{Utf8Path, Utf8PathBuf};
 use create_output_dir::{
     EXECUTE_PRINT_OUTPUT_FILENAME, EXECUTE_PROGRAM_OUTPUT_FILENAME, create_output_dir,
+    incremental_create_execution_output_dir,
 };
 use indoc::formatdoc;
 use scarb_extensions_cli::execute::{
@@ -38,7 +39,6 @@ mod profiler;
 
 pub(crate) mod output;
 
-const MAX_ITERATION_COUNT: usize = 10000;
 const EXECUTION_ID_ENV: &str = "SCARB_EXECUTION_ID";
 
 pub fn main_inner(args: Args, ui: Ui) -> Result<()> {
@@ -473,24 +473,7 @@ fn get_or_create_output_dir(output_dir: &Utf8Path) -> Result<Utf8PathBuf> {
         );
         return Ok(execution_output_dir);
     }
-    incremental_create_output_dir(output_dir)
-}
-
-fn incremental_create_output_dir(path: &Utf8Path) -> Result<Utf8PathBuf> {
-    for i in 1..=MAX_ITERATION_COUNT {
-        let filepath = path.join(format!("execution{i}"));
-        let result = fs::create_dir(&filepath);
-        return match result {
-            Err(e) => {
-                if e.kind() == io::ErrorKind::AlreadyExists {
-                    continue;
-                }
-                Err(e.into())
-            }
-            Ok(_) => Ok(filepath),
-        };
-    }
-    bail!("failed to create output directory")
+    incremental_create_execution_output_dir(output_dir).map(|(path, _execution_id)| path)
 }
 
 /// Writer implementation for a file.

extensions/scarb-prove/src/main.rs

@@ -1,10 +1,10 @@
 #![deny(clippy::dbg_macro)]
 #![deny(clippy::disallowed_methods)]
 
-use anyhow::{Context, Result, bail, ensure};
+use anyhow::{Context, Result, ensure};
 use camino::{Utf8Path, Utf8PathBuf};
 use clap::Parser;
-use create_output_dir::create_output_dir;
+use create_output_dir::{create_output_dir, incremental_create_execution_output_dir};
 use indoc::{formatdoc, indoc};
 use mimalloc::MiMalloc;
 use scarb_extensions_cli::execute::ToArgs;
@@ -13,9 +13,9 @@ use scarb_metadata::{Metadata, MetadataCommand, ScarbCommand};
 use scarb_ui::args::{PackagesFilter, ToEnvVars};
 use scarb_ui::components::Status;
 use scarb_ui::{OutputFormat, Ui};
+use std::env;
 use std::fs;
 use std::process::ExitCode;
-use std::{env, io};
 use stwo_cairo_adapter::vm_import::adapt_vm_output;
 use stwo_cairo_prover::cairo_air::prover::{
     ProverConfig, ProverParameters, default_prod_prover_parameters, prove_cairo,
@@ -25,8 +25,6 @@ use stwo_cairo_prover::stwo_prover::core::vcs::blake2_merkle::Blake2sMerkleChann
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
 
-const MAX_ITERATION_COUNT: usize = 10000;
-
 fn main() -> ExitCode {
     let args = Args::parse();
     let ui = Ui::new(args.verbose.clone().into(), OutputFormat::Text);
@@ -65,7 +63,8 @@ fn main_inner(args: Args, ui: Ui) -> Result<()> {
             let scarb_target_dir = Utf8PathBuf::from(env::var("SCARB_TARGET_DIR")?);
             let output_dir = scarb_target_dir.join("execute").join(&package.name);
             create_output_dir(output_dir.as_std_path())?;
-            let (_execution_output_dir, execution_id) = incremental_create_output_dir(&output_dir)?;
+            let (_execution_output_dir, execution_id) =
+                incremental_create_execution_output_dir(&output_dir)?;
 
             let filter = PackagesFilter::generate_for::<Metadata>(vec![package.clone()].iter());
             ScarbCommand::new()
@@ -163,20 +162,3 @@ fn display_path(scarb_target_dir: &Utf8Path, output_path: &Utf8Path) -> String {
         Err(_) => output_path.to_string(),
     }
 }
-
-fn incremental_create_output_dir(path: &Utf8Path) -> Result<(Utf8PathBuf, usize)> {
-    for i in 1..=MAX_ITERATION_COUNT {
-        let filepath = path.join(format!("execution{i}"));
-        let result = fs::create_dir(&filepath);
-        return match result {
-            Err(e) => {
-                if e.kind() == io::ErrorKind::AlreadyExists {
-                    continue;
-                }
-                Err(e.into())
-            }
-            Ok(_) => Ok((filepath, i)),
-        };
-    }
-    bail!("failed to create output directory")
-}

utils/create-output-dir/src/lib.rs

@@ -6,10 +6,13 @@
 //!
 //! [cargo-util-fn]: https://docs.rs/cargo-util/latest/cargo_util/paths/fn.create_dir_all_excluded_from_backups_atomic.html
 
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Result};
 use std::ffi::OsStr;
 use std::path::Path;
-use std::{env, fs};
+use std::{env, fs, io};
+use camino::{Utf8Path, Utf8PathBuf};
+
+const MAX_ITERATION_COUNT: usize = 10000;
 
 pub const EXECUTE_PROGRAM_OUTPUT_FILENAME: &str = "program_output.txt";
 pub const EXECUTE_PRINT_OUTPUT_FILENAME: &str = "stdout_output.txt";
@@ -60,6 +63,27 @@ pub fn create_output_dir(path: &Path) -> Result<()> {
     Ok(())
 }
 
+/// Creates an incremental execution output dir inside the given path.
+/// The dir name is `execution{N}` with the lowest `N` without existing dir.
+///
+/// Returns the path to the created directory and corresponding `N`.
+pub fn incremental_create_execution_output_dir(path: &Utf8Path) -> Result<(Utf8PathBuf, usize)> {
+    for i in 1..=MAX_ITERATION_COUNT {
+        let filepath = path.join(format!("execution{i}"));
+        let result = fs::create_dir(&filepath);
+        return match result {
+            Err(e) => {
+                if e.kind() == io::ErrorKind::AlreadyExists {
+                    continue;
+                }
+                Err(e.into())
+            }
+            Ok(_) => Ok((filepath, i)),
+        };
+    }
+    bail!("failed to create output directory")
+}
+
 /// Marks the directory as excluded from archives/backups.
 ///
 /// This is recommended to prevent derived/temporary files from bloating backups.