Add option for disabling closure computation in GHA cache

Allows to only cache the built derivations without their closures.

This avoids polluting the GHA cache with many duplicate entries, which
happens when a downstream derivation changes (and is rebuilt), but
its dependencies don't (but would get pushed to the cache each time
regardless).

magic-nix-cache/src/gha.rs

@@ -21,6 +21,8 @@ pub struct GhaCache {
     worker_result: RwLock<Option<tokio::task::JoinHandle<Result<()>>>>,
 
     channel_tx: UnboundedSender<Request>,
+
+    compute_closure: bool,
 }
 
 #[derive(Debug)]
@@ -36,6 +38,7 @@ impl GhaCache {
         store: Arc<NixStore>,
         metrics: Arc<telemetry::TelemetryReport>,
         narinfo_negative_cache: Arc<RwLock<HashSet<String>>>,
+        compute_closure: bool,
     ) -> Result<GhaCache> {
         let mut api = Api::new(credentials)?;
 
@@ -64,6 +67,7 @@ impl GhaCache {
             api,
             worker_result: RwLock::new(Some(worker_result)),
             channel_tx,
+            compute_closure,
         })
     }
 
@@ -85,18 +89,18 @@ impl GhaCache {
         store: Arc<NixStore>,
         store_paths: Vec<StorePath>,
     ) -> Result<()> {
-        // FIXME: make sending the closure optional. We might want to
-        // only send the paths that have been built by the user, under
-        // the assumption that everything else is already in a binary
-        // cache.
-        // FIXME: compute_fs_closure_multi doesn't return a
-        // toposort, though it doesn't really matter for the GHA
-        // cache.
-        let closure = store
-            .compute_fs_closure_multi(store_paths, false, false, false)
-            .await?;
-
-        for p in closure {
+        let final_paths = if self.compute_closure {
+            // FIXME: compute_fs_closure_multi doesn't return a
+            // toposort, though it doesn't really matter for the GHA
+            // cache.
+            store
+                .compute_fs_closure_multi(store_paths, false, false, false)
+                .await?
+        } else {
+            store_paths
+        };
+
+        for p in final_paths {
             self.channel_tx
                 .send(Request::Upload(p))
                 .map_err(|_| Error::Internal("Cannot send upload message".to_owned()))?;

magic-nix-cache/src/main.rs

@@ -127,6 +127,10 @@ struct Args {
     /// Whether or not to diff the store before and after Magic Nix Cache runs
     #[arg(long, default_value_t = false)]
     diff_store: bool,
+
+    /// (GHA only) Don't include the closure of the to-be-cached store paths
+    #[arg(long, default_value_t = false)]
+    no_closure: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, clap::ValueEnum)]
@@ -389,6 +393,7 @@ async fn main_cli() -> Result<()> {
             store.clone(),
             metrics.clone(),
             narinfo_negative_cache.clone(),
+            !args.no_closure,
         )
         .with_context(|| "Failed to initialize GitHub Actions Cache API")?;