new: Track operations for other actions. (#1476)

* Switch to a meta enum.

* Fix tests.

* Update ts.

* Add to sync workspace.

* Add to install deps.

* Add track methods.

* Move constructors.

* Polish.

* Check df.

* Turn off cache.

.github/workflows/moon.yml

@@ -30,6 +30,7 @@ jobs:
       - uses: actions/setup-node@v4
       - uses: moonrepo/setup-rust@v1
         with:
+          cache: false # Temporary, CI running out of space
           cache-base: '^(master|develop-)'
       - run: cargo run -- --color --log trace ci --base ${{ github.base_ref || 'master' }}
         env:

crates/bun/platform/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
+moon_action = { path = "../../../nextgen/action" }
 moon_action_context = { path = "../../../nextgen/action-context" }
 moon_bun_lang = { path = "../lang" }
 moon_bun_tool = { path = "../tool" }

crates/bun/platform/src/actions/install_deps.rs

@@ -1,3 +1,4 @@
+use moon_action::Operation;
 use moon_bun_tool::BunTool;
 use moon_console::{Checkpoint, Console};
 use moon_lang::has_vendor_installed_dependencies;
@@ -12,7 +13,9 @@ pub async fn install_deps(
     bun: &BunTool,
     working_dir: &Path,
     console: &Console,
-) -> miette::Result<()> {
+) -> miette::Result<Vec<Operation>> {
+    let mut operations = vec![];
+
     // When in CI, we can avoid installing dependencies because
     // we can assume they've already been installed before moon runs!
     if is_ci() && has_vendor_installed_dependencies(working_dir, "node_modules") {
@@ -21,7 +24,7 @@ pub async fn install_deps(
             "In a CI environment and dependencies already exist, skipping install"
         );
 
-        return Ok(());
+        return Ok(operations);
     }
 
     debug!(target: LOG_TARGET, "Installing dependencies");
@@ -30,8 +33,11 @@ pub async fn install_deps(
         .out
         .print_checkpoint(Checkpoint::Setup, "bun install")?;
 
-    bun.install_dependencies(&(), working_dir, !is_test_env())
-        .await?;
+    operations.push(
+        Operation::task_execution("bun install")
+            .track_async(|| bun.install_dependencies(&(), working_dir, !is_test_env()))
+            .await?,
+    );
 
-    Ok(())
+    Ok(operations)
 }

crates/bun/platform/src/bun_platform.rs

@@ -1,5 +1,6 @@
 use crate::actions;
 use crate::infer_tasks_from_scripts;
+use moon_action::Operation;
 use moon_action_context::ActionContext;
 use moon_bun_tool::{get_bun_env_paths, BunTool};
 use moon_common::Id;
@@ -321,15 +322,13 @@ impl Platform for BunPlatform {
         _context: &ActionContext,
         runtime: &Runtime,
         working_dir: &Path,
-    ) -> miette::Result<()> {
+    ) -> miette::Result<Vec<Operation>> {
         actions::install_deps(
             self.toolchain.get_for_version(&runtime.requirement)?,
             working_dir,
             &self.console,
         )
-        .await?;
-
-        Ok(())
+        .await
     }
 
     async fn sync_project(

crates/cli/src/commands/syncs/codeowners.rs

@@ -36,7 +36,11 @@ pub async fn sync(args: ArgsRef<SyncCodeownersArgs>, workspace: ResourceMut<Work
         done(
             format!(
                 "Successfully created {}",
-                color::path(codeowners_path.strip_prefix(&workspace.root).unwrap())
+                if let Some(path) = codeowners_path {
+                    color::path(path.strip_prefix(&workspace.root).unwrap())
+                } else {
+                    "code owners".into()
+                }
             ),
             true,
         );

crates/core/action-pipeline/src/actions/install_deps.rs

@@ -1,6 +1,6 @@
 use super::should_skip_action_matching;
 use miette::IntoDiagnostic;
-use moon_action::{Action, ActionStatus};
+use moon_action::{Action, ActionStatus, Operation};
 use moon_action_context::ActionContext;
 use moon_cache_item::cache_item;
 use moon_logger::{debug, warn};
@@ -38,7 +38,7 @@ fn get_installation_key(runtime: &Runtime, project: Option<&Project>) -> String
 }
 
 pub async fn install_deps(
-    _action: &mut Action,
+    action: &mut Action,
     context: Arc<ActionContext>,
     workspace: Arc<Workspace>,
     runtime: &Runtime,
@@ -110,6 +110,8 @@ pub async fn install_deps(
     };
 
     // Determine the working directory and whether lockfiles and manifests have been modified
+    let mut operation = Operation::hash_generation();
+
     let working_dir = project.map(|p| &p.root).unwrap_or_else(|| &workspace.root);
     let manifest_path = working_dir.join(&manifest);
     let lockfile_path = working_dir.join(&lockfile);
@@ -148,6 +150,11 @@ pub async fn install_deps(
     // Install dependencies in the working directory
     let hash = workspace.cache_engine.hash.save_manifest(hasher)?;
 
+    operation.meta.set_hash(&hash);
+    operation.finish(ActionStatus::Passed);
+
+    action.operations.push(operation);
+
     let state_path = format!("deps{runtime}.json");
     let mut state = workspace
         .cache_engine
@@ -175,14 +182,16 @@ pub async fn install_deps(
             color::path(working_dir)
         );
 
-        platform
+        let operations = platform
             .install_deps(&context, runtime, working_dir)
             .await?;
 
         state.data.last_hash = hash;
         state.data.last_install_time = time::now_millis();
         state.save()?;
 
+        action.operations.extend(operations);
+
         env::remove_var("MOON_INSTALLING_DEPS");
 
         return Ok(ActionStatus::Passed);

crates/core/action-pipeline/src/actions/run_task.rs

@@ -29,13 +29,18 @@ pub async fn run_task(
 
     let task = project.get_task(&target.task_id)?;
 
+    // Must be set before running the task in case it fails and
+    // and error is bubbled up the stack
     action.allow_failure = task.options.allow_failure;
 
     let result = TaskRunner::new(&workspace, project, task, console)?
         .run(&context, &action.node)
         .await?;
+    let operations = result.operations;
 
-    action.set_operations(result.operations, &task.command);
+    action.flaky = operations.is_flaky();
+    action.status = operations.get_final_status();
+    action.operations = operations;
 
     if action.has_failed() && action.allow_failure {
         warn!(

crates/core/action-pipeline/src/actions/sync_workspace.rs

@@ -1,5 +1,5 @@
 use super::should_skip_action;
-use moon_action::{Action, ActionStatus};
+use moon_action::{Action, ActionStatus, Operation};
 use moon_action_context::ActionContext;
 use moon_actions::{sync_codeowners, sync_vcs_hooks};
 use moon_common::is_docker_container;
@@ -14,7 +14,7 @@ use std::sync::Arc;
 const LOG_TARGET: &str = "moon:action:sync-workspace";
 
 pub async fn sync_workspace(
-    _action: &mut Action,
+    action: &mut Action,
     _context: Arc<ActionContext>,
     workspace: Arc<Workspace>,
     project_graph: Arc<ProjectGraph>,
@@ -47,7 +47,14 @@ pub async fn sync_workspace(
             color::property("codeowners.syncOnRun"),
         );
 
-        sync_codeowners(&workspace, &project_graph, false).await?;
+        action.operations.push(
+            Operation::sync_operation("Codeowners")
+                .track_async_with_check(
+                    || sync_codeowners(&workspace, &project_graph, false),
+                    |result| result.is_some(),
+                )
+                .await?,
+        );
     }
 
     if workspace.config.vcs.sync_hooks {
@@ -58,7 +65,11 @@ pub async fn sync_workspace(
             color::property("vcs.syncHooks"),
         );
 
-        sync_vcs_hooks(&workspace, false).await?;
+        action.operations.push(
+            Operation::sync_operation("VCS hooks")
+                .track_async_with_check(|| sync_vcs_hooks(&workspace, false), |result| result)
+                .await?,
+        );
     }
 
     Ok(ActionStatus::Passed)

crates/core/action-pipeline/src/subscribers/moonbase.rs

@@ -1,5 +1,5 @@
 use ci_env::get_environment;
-use moon_action::{ActionStatus, OperationType};
+use moon_action::ActionStatus;
 use moon_api::graphql::{
     self, add_job_to_run, create_run, update_job, update_run, AddJobToRun, CreateRun, GraphQLQuery,
     UpdateJob, UpdateRun,
@@ -323,7 +323,7 @@ impl Subscriber for MoonbaseSubscriber {
                         let attempts = action
                             .operations
                             .iter()
-                            .filter(|op| matches!(op.type_of, OperationType::TaskExecution))
+                            .filter(|op| op.meta.is_task_execution())
                             .collect::<Vec<_>>();
 
                         if !attempts.is_empty() {

crates/core/actions/src/sync_codeowners.rs

@@ -8,7 +8,7 @@ pub async fn sync_codeowners(
     workspace: &Workspace,
     project_graph: &ProjectGraph,
     force: bool,
-) -> miette::Result<PathBuf> {
+) -> miette::Result<Option<PathBuf>> {
     let mut generator = CodeownersGenerator::new(&workspace.root, workspace.config.vcs.provider)?;
 
     // Sort the projects based on config
@@ -44,18 +44,21 @@ pub async fn sync_codeowners(
     // Force run the generator and bypass cache
     if force {
         generator.generate()?;
+
+        return Ok(Some(file_path));
     }
     // Only generate if the hash has changed
-    else {
-        workspace
-            .cache_engine
-            .execute_if_changed("codeowners.json", codeowners_hash, || async {
-                generator.generate()
-            })
-            .await?;
+    else if workspace
+        .cache_engine
+        .execute_if_changed("codeowners.json", codeowners_hash, || async {
+            generator.generate()
+        })
+        .await?
+    {
+        return Ok(Some(file_path));
     }
 
-    Ok(file_path)
+    Ok(None)
 }
 
 pub async fn unsync_codeowners(workspace: &Workspace) -> miette::Result<PathBuf> {

crates/core/actions/src/sync_vcs_hooks.rs

@@ -1,13 +1,15 @@
 use moon_vcs_hooks::{HooksGenerator, HooksHash};
 use moon_workspace::Workspace;
 
-pub async fn sync_vcs_hooks(workspace: &Workspace, force: bool) -> miette::Result<()> {
+pub async fn sync_vcs_hooks(workspace: &Workspace, force: bool) -> miette::Result<bool> {
     let vcs_config = &workspace.config.vcs;
     let generator = HooksGenerator::new(&workspace.root, &workspace.vcs, vcs_config);
 
     // Force run the generator and bypass cache
     if force {
-        return generator.generate().await;
+        generator.generate().await?;
+
+        return Ok(true);
     }
 
     // Hash all the hook commands
@@ -23,9 +25,7 @@ pub async fn sync_vcs_hooks(workspace: &Workspace, force: bool) -> miette::Resul
         .execute_if_changed("vcsHooks.json", hooks_hash, || async {
             generator.generate().await
         })
-        .await?;
-
-    Ok(())
+        .await
 }
 
 pub async fn unsync_vcs_hooks(workspace: &Workspace) -> miette::Result<()> {

crates/core/platform/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
+moon_action = { path = "../../../nextgen/action" }
 moon_action_context = { path = "../../../nextgen/action-context" }
 moon_common = { path = "../../../nextgen/common" }
 moon_config = { path = "../../../nextgen/config" }

crates/core/platform/src/platform.rs

@@ -1,4 +1,5 @@
 use async_trait::async_trait;
+use moon_action::Operation;
 use moon_action_context::ActionContext;
 use moon_common::Id;
 use moon_config::{
@@ -115,8 +116,8 @@ pub trait Platform: Send + Sync {
         context: &ActionContext,
         runtime: &Runtime,
         working_dir: &Path,
-    ) -> miette::Result<()> {
-        Ok(())
+    ) -> miette::Result<Vec<Operation>> {
+        Ok(vec![])
     }
 
     /// Sync a project (and its dependencies) when applicable.

crates/deno/platform/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
+moon_action = { path = "../../../nextgen/action" }
 moon_action_context = { path = "../../../nextgen/action-context" }
 moon_common = { path = "../../../nextgen/common" }
 moon_config = { path = "../../../nextgen/config" }