Merge pull request #127 from DeterminateSystems/eelcodolstra/fh-865-add-nix-flake-prefetch-inputs-command-to-fetch-inputs-in

nix flake prefetch-inputs: Add

src/libcmd/include/nix/cmd/common-eval-args.hh

@@ -5,6 +5,7 @@
 #include "nix/util/canon-path.hh"
 #include "nix/main/common-args.hh"
 #include "nix/expr/search-path.hh"
+#include "nix/expr/eval-settings.hh"
 
 #include <filesystem>
 
@@ -15,10 +16,8 @@ class Store;
 namespace fetchers { struct Settings; }
 
 class EvalState;
-struct EvalSettings;
 struct CompatibilitySettings;
 class Bindings;
-struct SourcePath;
 
 namespace flake { struct Settings; }
 

src/nix/flake-command.hh

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "nix/cmd/command.hh"
+#include "nix/cmd/installable-flake.hh"
+#include "nix/flake/flake.hh"
+
+namespace nix {
+
+using namespace nix::flake;
+
+class FlakeCommand : virtual Args, public MixFlakeOptions
+{
+protected:
+    std::string flakeUrl = ".";
+
+public:
+
+    FlakeCommand();
+
+    FlakeRef getFlakeRef();
+
+    LockedFlake lockFlake();
+
+    std::vector<FlakeRef> getFlakeRefsForCompletion() override;
+};
+
+}

src/nix/flake-prefetch-inputs.cc

@@ -0,0 +1,72 @@
+#include "flake-command.hh"
+#include "nix/fetchers/fetch-to-store.hh"
+#include "nix/util/thread-pool.hh"
+#include "nix/store/filetransfer.hh"
+#include "nix/util/exit.hh"
+
+#include <nlohmann/json.hpp>
+
+using namespace nix;
+using namespace nix::flake;
+
+struct CmdFlakePrefetchInputs : FlakeCommand
+{
+    std::string description() override
+    {
+        return "fetch the inputs of a flake";
+    }
+
+    std::string doc() override
+    {
+        return
+#include "flake-prefetch-inputs.md"
+            ;
+    }
+
+    void run(nix::ref<nix::Store> store) override
+    {
+        auto flake = lockFlake();
+
+        ThreadPool pool{fileTransferSettings.httpConnections};
+
+        struct State
+        {
+            std::set<const Node *> done;
+        };
+
+        Sync<State> state_;
+
+        std::atomic<size_t> nrFailed{0};
+
+        std::function<void(const Node & node)> visit;
+        visit = [&](const Node & node) {
+            if (!state_.lock()->done.insert(&node).second)
+                return;
+
+            if (auto lockedNode = dynamic_cast<const LockedNode *>(&node)) {
+                try {
+                    Activity act(*logger, lvlInfo, actUnknown, fmt("fetching '%s'", lockedNode->lockedRef));
+                    auto accessor = lockedNode->lockedRef.input.getAccessor(store).first;
+                    if (!evalSettings.lazyTrees)
+                        fetchToStore(*store, accessor, FetchMode::Copy, lockedNode->lockedRef.input.getName());
+                } catch (Error & e) {
+                    printError("%s", e.what());
+                    nrFailed++;
+                }
+            }
+
+            for (auto & [inputName, input] : node.inputs) {
+                if (auto inputNode = std::get_if<0>(&input))
+                    pool.enqueue(std::bind(visit, **inputNode));
+            }
+        };
+
+        pool.enqueue(std::bind(visit, *flake.lockFile.root));
+
+        pool.process();
+
+        throw Exit(nrFailed ? 1 : 0);
+    }
+};
+
+static auto rCmdFlakePrefetchInputs = registerCommand2<CmdFlakePrefetchInputs>({"flake", "prefetch-inputs"});

src/nix/flake-prefetch-inputs.md

@@ -0,0 +1,17 @@
+R""(
+
+# Examples
+
+* Fetch the inputs of the `hydra` flake:
+
+  ```console
+  # nix flake prefetch-inputs github:NixOS/hydra
+  ```
+
+# Description
+
+Fetch the inputs of a flake. This ensures that they are already available for any subsequent evaluation of the flake.
+
+This operation is recursive: it will fetch not just the direct inputs of the top-level flake, but also transitive inputs.
+
+)""

src/nix/flake.cc

@@ -1,11 +1,9 @@
-#include "nix/cmd/command.hh"
-#include "nix/cmd/installable-flake.hh"
+#include "flake-command.hh"
 #include "nix/main/common-args.hh"
 #include "nix/main/shared.hh"
 #include "nix/expr/eval.hh"
 #include "nix/expr/eval-inline.hh"
 #include "nix/expr/eval-settings.hh"
-#include "nix/flake/flake.hh"
 #include "nix/expr/get-drvs.hh"
 #include "nix/util/signals.hh"
 #include "nix/store/store-open.hh"
@@ -33,14 +31,8 @@ using namespace nix::flake;
 using json = nlohmann::json;
 
 struct CmdFlakeUpdate;
-class FlakeCommand : virtual Args, public MixFlakeOptions
-{
-protected:
-    std::string flakeUrl = ".";
 
-public:
-
-    FlakeCommand()
+FlakeCommand::FlakeCommand()
 {
     expectArgs({
         .label = "flake-url",
@@ -52,24 +44,23 @@ public:
     });
 }
 
-    FlakeRef getFlakeRef()
+FlakeRef FlakeCommand::getFlakeRef()
 {
     return parseFlakeRef(fetchSettings, flakeUrl, std::filesystem::current_path().string()); //FIXME
 }
 
-    LockedFlake lockFlake()
+LockedFlake FlakeCommand::lockFlake()
 {
     return flake::lockFlake(flakeSettings, *getEvalState(), getFlakeRef(), lockFlags);
 }
 
-    std::vector<FlakeRef> getFlakeRefsForCompletion() override
+std::vector<FlakeRef> FlakeCommand::getFlakeRefsForCompletion()
 {
     return {
         // Like getFlakeRef but with expandTilde calld first
         parseFlakeRef(fetchSettings, expandTilde(flakeUrl), std::filesystem::current_path().string())
     };
 }
-};
 
 struct CmdFlakeUpdate : FlakeCommand
 {
@@ -1531,21 +1522,7 @@ struct CmdFlakePrefetch : FlakeCommand, MixJSON
 struct CmdFlake : NixMultiCommand
 {
     CmdFlake()
-        : NixMultiCommand(
-            "flake",
-            {
-                {"update", []() { return make_ref<CmdFlakeUpdate>(); }},
-                {"lock", []() { return make_ref<CmdFlakeLock>(); }},
-                {"metadata", []() { return make_ref<CmdFlakeMetadata>(); }},
-                {"info", []() { return make_ref<CmdFlakeInfo>(); }},
-                {"check", []() { return make_ref<CmdFlakeCheck>(); }},
-                {"init", []() { return make_ref<CmdFlakeInit>(); }},
-                {"new", []() { return make_ref<CmdFlakeNew>(); }},
-                {"clone", []() { return make_ref<CmdFlakeClone>(); }},
-                {"archive", []() { return make_ref<CmdFlakeArchive>(); }},
-                {"show", []() { return make_ref<CmdFlakeShow>(); }},
-                {"prefetch", []() { return make_ref<CmdFlakePrefetch>(); }},
-            })
+        : NixMultiCommand("flake", RegisterCommand::getCommandsFor({"flake"}))
     {
     }
 
@@ -1563,3 +1540,14 @@ struct CmdFlake : NixMultiCommand
 };
 
 static auto rCmdFlake = registerCommand<CmdFlake>("flake");
+static auto rCmdFlakeArchive = registerCommand2<CmdFlakeArchive>({"flake", "archive"});
+static auto rCmdFlakeCheck = registerCommand2<CmdFlakeCheck>({"flake", "check"});
+static auto rCmdFlakeClone = registerCommand2<CmdFlakeClone>({"flake", "clone"});
+static auto rCmdFlakeInfo = registerCommand2<CmdFlakeInfo>({"flake", "info"});
+static auto rCmdFlakeInit = registerCommand2<CmdFlakeInit>({"flake", "init"});
+static auto rCmdFlakeLock = registerCommand2<CmdFlakeLock>({"flake", "lock"});
+static auto rCmdFlakeMetadata = registerCommand2<CmdFlakeMetadata>({"flake", "metadata"});
+static auto rCmdFlakeNew = registerCommand2<CmdFlakeNew>({"flake", "new"});
+static auto rCmdFlakePrefetch = registerCommand2<CmdFlakePrefetch>({"flake", "prefetch"});
+static auto rCmdFlakeShow = registerCommand2<CmdFlakeShow>({"flake", "show"});
+static auto rCmdFlakeUpdate = registerCommand2<CmdFlakeUpdate>({"flake", "update"});

src/nix/meson.build

@@ -78,6 +78,7 @@ nix_sources = [config_priv_h] + files(
   'env.cc',
   'eval.cc',
   'flake.cc',
+  'flake-prefetch-inputs.cc',
   'formatter.cc',
   'hash.cc',
   'log.cc',