nixos/nix
1
1
Fork 0
mirror of https://github.com/NixOS/nix.git synced 2025-11-12 21:46:01 +01:00
Code Activity

Move FlakeCommand into a header, allow separate registration of subcommands

Browse source 
This allows us to start splitting up src/nix/flake.cc.
This commit is contained in:
Eelco Dolstra 2025-06-26 17:04:34 +02:00
parent 1ef1675300
commit e04aa2b13b
5 changed files with 130 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -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; }

27
src/nix/flake-command.hh Normal file
View file

@ -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;
};
}

62
src/nix/flake-prefetch-inputs.cc Normal file
View file

@ -0,0 +1,62 @@
#include "flake-command.hh"
#include "nix/fetchers/fetch-to-store.hh"
#include "nix/util/thread-pool.hh"
#include "nix/store/filetransfer.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::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)) {
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());
}
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();
}
};
static auto rCmdFlakePrefetchInputs = registerCommand2<CmdFlakePrefetchInputs>({"flake", "prefetch-inputs"});

118
src/nix/flake.cc
View file

@ -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"
@ -19,8 +17,6 @@
#include "nix/util/users.hh"
#include "nix/fetchers/fetch-to-store.hh"
#include "nix/store/local-fs-store.hh"
#include "nix/util/thread-pool.hh"
#include "nix/store/filetransfer.hh"
#include <filesystem>
#include <nlohmann/json.hpp>
@ -35,15 +31,9 @@ using namespace nix::flake;
using json = nlohmann::json;
struct CmdFlakeUpdate;
class FlakeCommand : virtual Args, public MixFlakeOptions
FlakeCommand::FlakeCommand()
{
protected:
std::string flakeUrl = ".";
public:
FlakeCommand()
{
expectArgs({
.label = "flake-url",
.optional = true,
@ -52,26 +42,25 @@ public:
completeFlakeRef(completions, getStore(), prefix);
}}
});
}
}
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
{
@ -1142,59 +1131,6 @@ struct CmdFlakeArchive : FlakeCommand, MixJSON, MixDryRun
}
};
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::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)) {
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());
}
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();
}
};
struct CmdFlakeShow : FlakeCommand, MixJSON
{
bool showLegacy = false;
@ -1586,22 +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>(); }},
{"prefetch-inputs", []() { return make_ref<CmdFlakePrefetchInputs>(); }},
{"show", []() { return make_ref<CmdFlakeShow>(); }},
{"prefetch", []() { return make_ref<CmdFlakePrefetch>(); }},
})
: NixMultiCommand("flake", RegisterCommand::getCommandsFor({"flake"}))
{
}
@ -1619,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"});

1
src/nix/meson.build
View file

@ -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',