2022-03-26 10:32:38 +00:00
|
|
|
#include "globals.hh"
|
2019-10-14 12:40:16 +00:00
|
|
|
#include "installables.hh"
|
2023-02-03 16:21:47 +00:00
|
|
|
#include "installable-derived-path.hh"
|
2023-02-03 19:53:40 +00:00
|
|
|
#include "installable-attr-path.hh"
|
|
|
|
#include "installable-flake.hh"
|
2023-01-11 06:51:14 +00:00
|
|
|
#include "outputs-spec.hh"
|
2022-02-19 13:26:34 +00:00
|
|
|
#include "util.hh"
|
2017-04-25 10:06:32 +00:00
|
|
|
#include "command.hh"
|
2016-02-09 20:34:24 +00:00
|
|
|
#include "attr-path.hh"
|
2017-10-24 10:45:11 +00:00
|
|
|
#include "common-eval-args.hh"
|
2016-02-09 20:34:24 +00:00
|
|
|
#include "derivations.hh"
|
|
|
|
#include "eval-inline.hh"
|
|
|
|
#include "eval.hh"
|
|
|
|
#include "get-drvs.hh"
|
|
|
|
#include "store-api.hh"
|
2017-04-25 09:20:37 +00:00
|
|
|
#include "shared.hh"
|
2019-06-05 14:51:54 +00:00
|
|
|
#include "flake/flake.hh"
|
2020-04-20 11:14:59 +00:00
|
|
|
#include "eval-cache.hh"
|
2020-03-30 12:03:28 +00:00
|
|
|
#include "url.hh"
|
2020-05-11 19:49:02 +00:00
|
|
|
#include "registry.hh"
|
2022-03-08 18:50:46 +00:00
|
|
|
#include "build-result.hh"
|
2017-04-25 09:20:37 +00:00
|
|
|
|
|
|
|
#include <regex>
|
2019-05-23 21:42:13 +00:00
|
|
|
#include <queue>
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2020-10-23 04:59:01 +00:00
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
|
2016-02-09 20:34:24 +00:00
|
|
|
namespace nix {
|
|
|
|
|
2019-05-22 11:46:07 +00:00
|
|
|
MixFlakeOptions::MixFlakeOptions()
|
2017-10-24 10:45:11 +00:00
|
|
|
{
|
2021-01-25 18:03:13 +00:00
|
|
|
auto category = "Common flake-related options";
|
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "recreate-lock-file",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Recreate the flake's lock file from scratch.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-05-05 16:59:33 +00:00
|
|
|
.handler = {&lockFlags.recreateLockFile, true}
|
|
|
|
});
|
2019-05-14 09:34:45 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "no-update-lock-file",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Do not allow any updates to the flake's lock file.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-05-05 16:59:33 +00:00
|
|
|
.handler = {&lockFlags.updateLockFile, false}
|
|
|
|
});
|
2020-01-29 20:01:34 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "no-write-lock-file",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Do not write the flake's newly generated lock file.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-05-05 16:59:33 +00:00
|
|
|
.handler = {&lockFlags.writeLockFile, false}
|
|
|
|
});
|
2019-05-14 09:34:45 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "no-registries",
|
2021-07-21 12:27:37 +00:00
|
|
|
.description =
|
|
|
|
"Don't allow lookups in the flake registries. This option is deprecated; use `--no-use-registries`.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2021-07-02 12:36:14 +00:00
|
|
|
.handler = {[&]() {
|
|
|
|
lockFlags.useRegistries = false;
|
2021-07-21 12:27:37 +00:00
|
|
|
warn("'--no-registries' is deprecated; use '--no-use-registries'");
|
2021-07-02 12:36:14 +00:00
|
|
|
}}
|
2020-05-05 16:59:33 +00:00
|
|
|
});
|
2020-01-29 13:57:57 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "commit-lock-file",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Commit changes to the flake's lock file.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-05-05 16:59:33 +00:00
|
|
|
.handler = {&lockFlags.commitLockFile, true}
|
|
|
|
});
|
2020-02-05 13:48:49 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "update-input",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Update a specific flake input (ignoring its previous entry in the lock file).",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-05-05 16:59:33 +00:00
|
|
|
.labels = {"input-path"},
|
|
|
|
.handler = {[&](std::string s) {
|
|
|
|
lockFlags.inputUpdates.insert(flake::parseInputPath(s));
|
2020-06-08 14:20:00 +00:00
|
|
|
}},
|
|
|
|
.completer = {[&](size_t, std::string_view prefix) {
|
2022-06-20 02:15:38 +00:00
|
|
|
needsFlakeInputCompletion = {std::string(prefix)};
|
2020-05-05 16:59:33 +00:00
|
|
|
}}
|
|
|
|
});
|
2020-01-29 22:12:58 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "override-input",
|
2021-03-16 15:53:39 +00:00
|
|
|
.description = "Override a specific flake input (e.g. `dwarffs/nixpkgs`). This implies `--no-write-lock-file`.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-05-05 16:59:33 +00:00
|
|
|
.labels = {"input-path", "flake-url"},
|
|
|
|
.handler = {[&](std::string inputPath, std::string flakeRef) {
|
2021-03-16 15:53:39 +00:00
|
|
|
lockFlags.writeLockFile = false;
|
2020-01-29 13:57:57 +00:00
|
|
|
lockFlags.inputOverrides.insert_or_assign(
|
2020-05-05 16:59:33 +00:00
|
|
|
flake::parseInputPath(inputPath),
|
2022-02-04 02:51:47 +00:00
|
|
|
parseFlakeRef(flakeRef, absPath("."), true));
|
2022-02-19 17:36:02 +00:00
|
|
|
}},
|
|
|
|
.completer = {[&](size_t n, std::string_view prefix) {
|
2022-06-19 15:54:27 +00:00
|
|
|
if (n == 0)
|
2022-06-20 02:15:38 +00:00
|
|
|
needsFlakeInputCompletion = {std::string(prefix)};
|
2022-06-19 15:54:27 +00:00
|
|
|
else if (n == 1)
|
2022-02-19 17:36:02 +00:00
|
|
|
completeFlakeRef(getEvalState()->store, prefix);
|
2020-05-05 16:59:33 +00:00
|
|
|
}}
|
|
|
|
});
|
2020-07-01 18:23:39 +00:00
|
|
|
|
|
|
|
addFlag({
|
|
|
|
.longName = "inputs-from",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Use the inputs of the specified flake as registry entries.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = category,
|
2020-07-01 18:23:39 +00:00
|
|
|
.labels = {"flake-url"},
|
|
|
|
.handler = {[&](std::string flakeRef) {
|
|
|
|
auto evalState = getEvalState();
|
|
|
|
auto flake = flake::lockFlake(
|
|
|
|
*evalState,
|
|
|
|
parseFlakeRef(flakeRef, absPath(".")),
|
|
|
|
{ .writeLockFile = false });
|
|
|
|
for (auto & [inputName, input] : flake.lockFile.root->inputs) {
|
|
|
|
auto input2 = flake.lockFile.findInput({inputName}); // resolve 'follows' nodes
|
|
|
|
if (auto input3 = std::dynamic_pointer_cast<const flake::LockedNode>(input2)) {
|
|
|
|
overrideRegistry(
|
|
|
|
fetchers::Input::fromAttrs({{"type","indirect"}, {"id", inputName}}),
|
|
|
|
input3->lockedRef.input,
|
|
|
|
{});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}},
|
|
|
|
.completer = {[&](size_t, std::string_view prefix) {
|
|
|
|
completeFlakeRef(getEvalState()->store, prefix);
|
|
|
|
}}
|
|
|
|
});
|
2019-05-22 11:46:07 +00:00
|
|
|
}
|
|
|
|
|
2022-06-20 02:15:38 +00:00
|
|
|
void MixFlakeOptions::completeFlakeInput(std::string_view prefix)
|
|
|
|
{
|
|
|
|
auto evalState = getEvalState();
|
|
|
|
for (auto & flakeRefS : getFlakesForCompletion()) {
|
|
|
|
auto flakeRef = parseFlakeRefWithFragment(expandTilde(flakeRefS), absPath(".")).first;
|
|
|
|
auto flake = flake::getFlake(*evalState, flakeRef, true);
|
|
|
|
for (auto & input : flake.inputs)
|
|
|
|
if (hasPrefix(input.first, prefix))
|
|
|
|
completions->add(input.first);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MixFlakeOptions::completionHook()
|
|
|
|
{
|
|
|
|
if (auto & prefix = needsFlakeInputCompletion)
|
|
|
|
completeFlakeInput(*prefix);
|
|
|
|
}
|
|
|
|
|
2023-02-05 01:45:40 +00:00
|
|
|
SourceExprCommand::SourceExprCommand()
|
2019-05-22 11:46:07 +00:00
|
|
|
{
|
2020-05-04 20:40:19 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "file",
|
|
|
|
.shortName = 'f',
|
2022-03-16 18:48:50 +00:00
|
|
|
.description =
|
|
|
|
"Interpret installables as attribute paths relative to the Nix expression stored in *file*. "
|
2022-06-10 15:00:19 +00:00
|
|
|
"If *file* is the character -, then a Nix expression will be read from standard input. "
|
|
|
|
"Implies `--impure`.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = installablesCategory,
|
2020-05-04 20:40:19 +00:00
|
|
|
.labels = {"file"},
|
2020-05-10 19:35:07 +00:00
|
|
|
.handler = {&file},
|
|
|
|
.completer = completePath
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
2019-11-26 23:05:30 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
2021-01-13 13:18:04 +00:00
|
|
|
.longName = "expr",
|
|
|
|
.description = "Interpret installables as attribute paths relative to the Nix expression *expr*.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = installablesCategory,
|
2020-05-05 16:59:33 +00:00
|
|
|
.labels = {"expr"},
|
|
|
|
.handler = {&expr}
|
|
|
|
});
|
2023-02-05 01:45:40 +00:00
|
|
|
}
|
2020-07-15 18:22:52 +00:00
|
|
|
|
2023-02-05 01:45:40 +00:00
|
|
|
MixReadOnlyOption::MixReadOnlyOption()
|
|
|
|
{
|
|
|
|
addFlag({
|
|
|
|
.longName = "read-only",
|
|
|
|
.description =
|
|
|
|
"Do not instantiate each evaluated derivation. "
|
|
|
|
"This improves performance, but can cause errors when accessing "
|
|
|
|
"store paths of derivations during evaluation.",
|
|
|
|
.handler = {&settings.readOnlyMode, true},
|
|
|
|
});
|
2017-10-24 10:45:11 +00:00
|
|
|
}
|
|
|
|
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
Strings SourceExprCommand::getDefaultFlakeAttrPaths()
|
|
|
|
{
|
2022-02-11 17:11:08 +00:00
|
|
|
return {
|
|
|
|
"packages." + settings.thisSystem.get() + ".default",
|
|
|
|
"defaultPackage." + settings.thisSystem.get()
|
|
|
|
};
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Strings SourceExprCommand::getDefaultFlakeAttrPathPrefixes()
|
|
|
|
{
|
|
|
|
return {
|
|
|
|
// As a convenience, look for the attribute in
|
|
|
|
// 'outputs.packages'.
|
|
|
|
"packages." + settings.thisSystem.get() + ".",
|
|
|
|
// As a temporary hack until Nixpkgs is properly converted
|
|
|
|
// to provide a clean 'packages' set, look in 'legacyPackages'.
|
|
|
|
"legacyPackages." + settings.thisSystem.get() + "."
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-05-11 19:49:02 +00:00
|
|
|
void SourceExprCommand::completeInstallable(std::string_view prefix)
|
|
|
|
{
|
2022-11-03 09:11:28 +00:00
|
|
|
try {
|
|
|
|
if (file) {
|
|
|
|
completionType = ctAttrs;
|
2022-02-19 17:51:18 +00:00
|
|
|
|
2022-11-03 09:11:28 +00:00
|
|
|
evalSettings.pureEval = false;
|
|
|
|
auto state = getEvalState();
|
|
|
|
Expr *e = state->parseExprFromFile(
|
|
|
|
resolveExprPath(state->checkSourcePath(lookupFileArg(*state, *file)))
|
|
|
|
);
|
2021-07-03 12:19:10 +00:00
|
|
|
|
2022-11-03 09:11:28 +00:00
|
|
|
Value root;
|
|
|
|
state->eval(e, root);
|
2020-05-11 19:49:02 +00:00
|
|
|
|
2022-11-03 09:11:28 +00:00
|
|
|
auto autoArgs = getAutoArgs(*state);
|
2021-07-03 12:19:10 +00:00
|
|
|
|
2022-11-03 09:11:28 +00:00
|
|
|
std::string prefix_ = std::string(prefix);
|
|
|
|
auto sep = prefix_.rfind('.');
|
|
|
|
std::string searchWord;
|
|
|
|
if (sep != std::string::npos) {
|
|
|
|
searchWord = prefix_.substr(sep + 1, std::string::npos);
|
|
|
|
prefix_ = prefix_.substr(0, sep);
|
|
|
|
} else {
|
|
|
|
searchWord = prefix_;
|
|
|
|
prefix_ = "";
|
|
|
|
}
|
2021-07-03 12:19:10 +00:00
|
|
|
|
2022-11-03 09:11:28 +00:00
|
|
|
auto [v, pos] = findAlongAttrPath(*state, prefix_, *autoArgs, root);
|
|
|
|
Value &v1(*v);
|
|
|
|
state->forceValue(v1, pos);
|
|
|
|
Value v2;
|
|
|
|
state->autoCallFunction(*autoArgs, v1, v2);
|
2021-07-03 12:19:10 +00:00
|
|
|
|
2022-11-03 09:11:28 +00:00
|
|
|
if (v2.type() == nAttrs) {
|
|
|
|
for (auto & i : *v2.attrs) {
|
|
|
|
std::string name = state->symbols[i.name];
|
|
|
|
if (name.find(searchWord) == 0) {
|
|
|
|
if (prefix_ == "")
|
|
|
|
completions->add(name);
|
|
|
|
else
|
|
|
|
completions->add(prefix_ + "." + name);
|
|
|
|
}
|
2021-07-05 19:37:33 +00:00
|
|
|
}
|
2021-07-03 12:19:10 +00:00
|
|
|
}
|
2022-11-03 09:11:28 +00:00
|
|
|
} else {
|
|
|
|
completeFlakeRefWithFragment(
|
|
|
|
getEvalState(),
|
|
|
|
lockFlags,
|
|
|
|
getDefaultFlakeAttrPathPrefixes(),
|
|
|
|
getDefaultFlakeAttrPaths(),
|
|
|
|
prefix);
|
2021-07-03 12:19:10 +00:00
|
|
|
}
|
2022-11-16 09:34:32 +00:00
|
|
|
} catch (EvalError&) {
|
|
|
|
// Don't want eval errors to mess-up with the completion engine, so let's just swallow them
|
2021-07-03 12:19:10 +00:00
|
|
|
}
|
2020-06-05 12:09:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void completeFlakeRefWithFragment(
|
|
|
|
ref<EvalState> evalState,
|
|
|
|
flake::LockFlags lockFlags,
|
|
|
|
Strings attrPathPrefixes,
|
|
|
|
const Strings & defaultFlakeAttrPaths,
|
|
|
|
std::string_view prefix)
|
|
|
|
{
|
2020-05-11 19:49:02 +00:00
|
|
|
/* Look for flake output attributes that match the
|
|
|
|
prefix. */
|
|
|
|
try {
|
|
|
|
auto hash = prefix.find('#');
|
2021-12-22 11:37:59 +00:00
|
|
|
if (hash == std::string::npos) {
|
|
|
|
completeFlakeRef(evalState->store, prefix);
|
|
|
|
} else {
|
2022-02-19 17:51:18 +00:00
|
|
|
completionType = ctAttrs;
|
|
|
|
|
2020-05-11 19:49:02 +00:00
|
|
|
auto fragment = prefix.substr(hash + 1);
|
|
|
|
auto flakeRefS = std::string(prefix.substr(0, hash));
|
2022-02-19 13:26:34 +00:00
|
|
|
auto flakeRef = parseFlakeRef(expandTilde(flakeRefS), absPath("."));
|
2020-05-11 19:49:02 +00:00
|
|
|
|
2020-06-05 12:09:12 +00:00
|
|
|
auto evalCache = openEvalCache(*evalState,
|
2020-08-07 12:13:24 +00:00
|
|
|
std::make_shared<flake::LockedFlake>(lockFlake(*evalState, flakeRef, lockFlags)));
|
2020-05-11 19:49:02 +00:00
|
|
|
|
|
|
|
auto root = evalCache->getRoot();
|
|
|
|
|
|
|
|
/* Complete 'fragment' relative to all the
|
|
|
|
attrpath prefixes as well as the root of the
|
|
|
|
flake. */
|
|
|
|
attrPathPrefixes.push_back("");
|
|
|
|
|
|
|
|
for (auto & attrPathPrefixS : attrPathPrefixes) {
|
2020-06-05 12:09:12 +00:00
|
|
|
auto attrPathPrefix = parseAttrPath(*evalState, attrPathPrefixS);
|
2020-05-11 19:49:02 +00:00
|
|
|
auto attrPathS = attrPathPrefixS + std::string(fragment);
|
2020-06-05 12:09:12 +00:00
|
|
|
auto attrPath = parseAttrPath(*evalState, attrPathS);
|
2020-05-11 19:49:02 +00:00
|
|
|
|
|
|
|
std::string lastAttr;
|
|
|
|
if (!attrPath.empty() && !hasSuffix(attrPathS, ".")) {
|
2022-04-22 19:45:39 +00:00
|
|
|
lastAttr = evalState->symbols[attrPath.back()];
|
2020-05-11 19:49:02 +00:00
|
|
|
attrPath.pop_back();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto attr = root->findAlongAttrPath(attrPath);
|
|
|
|
if (!attr) continue;
|
|
|
|
|
2022-03-04 08:44:00 +00:00
|
|
|
for (auto & attr2 : (*attr)->getAttrs()) {
|
2022-04-22 19:45:39 +00:00
|
|
|
if (hasPrefix(evalState->symbols[attr2], lastAttr)) {
|
2022-03-04 08:44:00 +00:00
|
|
|
auto attrPath2 = (*attr)->getAttrPath(attr2);
|
2020-05-11 19:49:02 +00:00
|
|
|
/* Strip the attrpath prefix. */
|
|
|
|
attrPath2.erase(attrPath2.begin(), attrPath2.begin() + attrPathPrefix.size());
|
2022-04-22 19:45:39 +00:00
|
|
|
completions->add(flakeRefS + "#" + concatStringsSep(".", evalState->symbols.resolve(attrPath2)));
|
2020-05-11 19:49:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And add an empty completion for the default
|
|
|
|
attrpaths. */
|
|
|
|
if (fragment.empty()) {
|
2020-06-05 12:09:12 +00:00
|
|
|
for (auto & attrPath : defaultFlakeAttrPaths) {
|
|
|
|
auto attr = root->findAlongAttrPath(parseAttrPath(*evalState, attrPath));
|
2020-05-11 19:49:02 +00:00
|
|
|
if (!attr) continue;
|
2020-10-09 07:39:51 +00:00
|
|
|
completions->add(flakeRefS + "#");
|
2020-05-11 19:49:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} catch (Error & e) {
|
|
|
|
warn(e.msg());
|
|
|
|
}
|
2020-05-11 20:10:33 +00:00
|
|
|
}
|
|
|
|
|
2020-06-05 12:09:12 +00:00
|
|
|
void completeFlakeRef(ref<Store> store, std::string_view prefix)
|
2020-05-11 20:10:33 +00:00
|
|
|
{
|
2021-11-26 15:56:25 +00:00
|
|
|
if (!settings.isExperimentalFeatureEnabled(Xp::Flakes))
|
|
|
|
return;
|
|
|
|
|
2020-05-11 20:10:33 +00:00
|
|
|
if (prefix == "")
|
2020-10-09 07:39:51 +00:00
|
|
|
completions->add(".");
|
2020-05-11 20:10:33 +00:00
|
|
|
|
|
|
|
completeDir(0, prefix);
|
|
|
|
|
2020-05-11 19:49:02 +00:00
|
|
|
/* Look for registry entries that match the prefix. */
|
2020-06-05 12:09:12 +00:00
|
|
|
for (auto & registry : fetchers::getRegistries(store)) {
|
2020-05-11 19:49:02 +00:00
|
|
|
for (auto & entry : registry->entries) {
|
Remove TreeInfo
The attributes previously stored in TreeInfo (narHash, revCount,
lastModified) are now stored in Input. This makes it less arbitrary
what attributes are stored where.
As a result, the lock file format has changed. An entry like
"info": {
"lastModified": 1585405475,
"narHash": "sha256-bESW0n4KgPmZ0luxvwJ+UyATrC6iIltVCsGdLiphVeE="
},
"locked": {
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "b88ff468e9850410070d4e0ccd68c7011f15b2be",
"type": "github"
},
is now stored as
"locked": {
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "b88ff468e9850410070d4e0ccd68c7011f15b2be",
"type": "github",
"lastModified": 1585405475,
"narHash": "sha256-bESW0n4KgPmZ0luxvwJ+UyATrC6iIltVCsGdLiphVeE="
},
The 'Input' class is now a dumb set of attributes. All the fetcher
implementations subclass InputScheme, not Input. This simplifies the
API.
Also, fix substitution of flake inputs. This was broken since lazy
flake fetching started using fetchTree internally.
2020-05-29 22:44:11 +00:00
|
|
|
auto from = entry.from.to_string();
|
2020-05-11 19:49:02 +00:00
|
|
|
if (!hasPrefix(prefix, "flake:") && hasPrefix(from, "flake:")) {
|
|
|
|
std::string from2(from, 6);
|
|
|
|
if (hasPrefix(from2, prefix))
|
2020-10-09 07:39:51 +00:00
|
|
|
completions->add(from2);
|
2020-05-11 19:49:02 +00:00
|
|
|
} else {
|
|
|
|
if (hasPrefix(from, prefix))
|
2020-10-09 07:39:51 +00:00
|
|
|
completions->add(from);
|
2020-05-11 19:49:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-15 21:09:32 +00:00
|
|
|
DerivedPathWithInfo Installable::toDerivedPath()
|
2017-09-06 14:03:22 +00:00
|
|
|
{
|
2021-05-17 06:45:08 +00:00
|
|
|
auto buildables = toDerivedPaths();
|
2017-09-06 14:03:22 +00:00
|
|
|
if (buildables.size() != 1)
|
|
|
|
throw Error("installable '%s' evaluates to %d derivations, where only one is expected", what(), buildables.size());
|
|
|
|
return std::move(buildables[0]);
|
|
|
|
}
|
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
std::vector<ref<eval_cache::AttrCursor>>
|
2020-08-07 12:13:24 +00:00
|
|
|
Installable::getCursors(EvalState & state)
|
2020-04-20 13:27:09 +00:00
|
|
|
{
|
|
|
|
auto evalCache =
|
2020-07-16 14:58:53 +00:00
|
|
|
std::make_shared<nix::eval_cache::EvalCache>(std::nullopt, state,
|
2020-04-20 13:27:09 +00:00
|
|
|
[&]() { return toValue(state).first; });
|
2022-04-14 12:04:19 +00:00
|
|
|
return {evalCache->getRoot()};
|
2020-04-20 13:27:09 +00:00
|
|
|
}
|
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
ref<eval_cache::AttrCursor>
|
2020-08-07 12:13:24 +00:00
|
|
|
Installable::getCursor(EvalState & state)
|
2020-06-04 18:02:50 +00:00
|
|
|
{
|
2023-01-30 15:56:27 +00:00
|
|
|
/* Although getCursors should return at least one element, in case it doesn't,
|
|
|
|
bound check to avoid an undefined behavior for vector[0] */
|
|
|
|
return getCursors(state).at(0);
|
2020-06-04 18:02:50 +00:00
|
|
|
}
|
|
|
|
|
2022-01-18 16:28:18 +00:00
|
|
|
static StorePath getDeriver(
|
|
|
|
ref<Store> store,
|
|
|
|
const Installable & i,
|
|
|
|
const StorePath & drvPath)
|
|
|
|
{
|
|
|
|
auto derivers = store->queryValidDerivers(drvPath);
|
|
|
|
if (derivers.empty())
|
|
|
|
throw Error("'%s' does not have a known deriver", i.what());
|
|
|
|
// FIXME: use all derivers?
|
|
|
|
return *derivers.begin();
|
|
|
|
}
|
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
ref<eval_cache::EvalCache> openEvalCache(
|
|
|
|
EvalState & state,
|
2020-08-07 12:13:24 +00:00
|
|
|
std::shared_ptr<flake::LockedFlake> lockedFlake)
|
2020-04-20 11:13:52 +00:00
|
|
|
{
|
2020-08-04 03:46:28 +00:00
|
|
|
auto fingerprint = lockedFlake->getFingerprint();
|
2020-07-16 14:58:53 +00:00
|
|
|
return make_ref<nix::eval_cache::EvalCache>(
|
2020-08-07 12:13:24 +00:00
|
|
|
evalSettings.useEvalCache && evalSettings.pureEval
|
2020-07-16 14:58:53 +00:00
|
|
|
? std::optional { std::cref(fingerprint) }
|
|
|
|
: std::nullopt,
|
2020-04-20 11:13:52 +00:00
|
|
|
state,
|
2020-04-20 13:27:09 +00:00
|
|
|
[&state, lockedFlake]()
|
2020-04-20 11:13:52 +00:00
|
|
|
{
|
|
|
|
/* For testing whether the evaluation cache is
|
|
|
|
complete. */
|
|
|
|
if (getEnv("NIX_ALLOW_EVAL").value_or("1") == "0")
|
|
|
|
throw Error("not everything is cached, but evaluation is not allowed");
|
|
|
|
|
|
|
|
auto vFlake = state.allocValue();
|
2020-04-20 13:27:09 +00:00
|
|
|
flake::callFlake(state, *lockedFlake, *vFlake);
|
2020-04-20 11:13:52 +00:00
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
state.forceAttrs(*vFlake, noPos, "while parsing cached flake data");
|
2020-04-20 11:13:52 +00:00
|
|
|
|
|
|
|
auto aOutputs = vFlake->attrs->get(state.symbols.create("outputs"));
|
|
|
|
assert(aOutputs);
|
|
|
|
|
|
|
|
return aOutputs->value;
|
2020-07-16 14:58:53 +00:00
|
|
|
});
|
2020-04-20 11:13:52 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
|
|
|
|
ref<Store> store, std::vector<std::string> ss)
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
|
|
|
std::vector<std::shared_ptr<Installable>> result;
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2019-11-26 23:05:30 +00:00
|
|
|
if (file || expr) {
|
|
|
|
if (file && expr)
|
|
|
|
throw UsageError("'--file' and '--expr' are exclusive");
|
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
// FIXME: backward compatibility hack
|
2019-11-26 23:05:30 +00:00
|
|
|
if (file) evalSettings.pureEval = false;
|
2017-04-25 13:18:05 +00:00
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
auto state = getEvalState();
|
|
|
|
auto vFile = state->allocValue();
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2022-03-16 18:48:50 +00:00
|
|
|
if (file == "-") {
|
|
|
|
auto e = state->parseStdin();
|
|
|
|
state->eval(e, *vFile);
|
2022-12-07 11:58:58 +00:00
|
|
|
}
|
|
|
|
else if (file)
|
2019-11-26 23:05:30 +00:00
|
|
|
state->evalFile(lookupFileArg(*state, *file), *vFile);
|
|
|
|
else {
|
|
|
|
auto e = state->parseExprFromString(*expr, absPath("."));
|
|
|
|
state->eval(e, *vFile);
|
|
|
|
}
|
2017-07-04 13:38:23 +00:00
|
|
|
|
2022-04-22 13:17:01 +00:00
|
|
|
for (auto & s : ss) {
|
2023-01-11 07:00:44 +00:00
|
|
|
auto [prefix, extendedOutputsSpec] = ExtendedOutputsSpec::parse(s);
|
2022-04-22 13:17:01 +00:00
|
|
|
result.push_back(
|
|
|
|
std::make_shared<InstallableAttrPath>(
|
2023-02-03 19:53:40 +00:00
|
|
|
InstallableAttrPath::parse(
|
|
|
|
state, *this, vFile, prefix, extendedOutputsSpec)));
|
2022-04-22 13:17:01 +00:00
|
|
|
}
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
} else {
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
for (auto & s : ss) {
|
2020-05-06 15:20:23 +00:00
|
|
|
std::exception_ptr ex;
|
|
|
|
|
2022-12-13 18:00:34 +00:00
|
|
|
auto [prefix_, extendedOutputsSpec_] = ExtendedOutputsSpec::parse(s);
|
|
|
|
// To avoid clang's pedantry
|
|
|
|
auto prefix = std::move(prefix_);
|
|
|
|
auto extendedOutputsSpec = std::move(extendedOutputsSpec_);
|
2021-02-12 21:51:36 +00:00
|
|
|
|
2023-02-03 16:21:47 +00:00
|
|
|
if (prefix.find('/') != std::string::npos) {
|
2020-04-27 20:53:11 +00:00
|
|
|
try {
|
2023-02-03 16:21:47 +00:00
|
|
|
result.push_back(std::make_shared<InstallableDerivedPath>(
|
|
|
|
InstallableDerivedPath::parse(store, prefix, extendedOutputsSpec)));
|
2020-04-27 20:53:11 +00:00
|
|
|
continue;
|
2020-07-14 11:56:18 +00:00
|
|
|
} catch (BadStorePath &) {
|
2020-04-27 20:53:11 +00:00
|
|
|
} catch (...) {
|
2020-05-06 15:20:23 +00:00
|
|
|
if (!ex)
|
|
|
|
ex = std::current_exception();
|
2020-04-27 20:53:11 +00:00
|
|
|
}
|
2020-05-06 15:20:23 +00:00
|
|
|
}
|
2020-04-27 20:53:11 +00:00
|
|
|
|
2020-05-06 15:20:23 +00:00
|
|
|
try {
|
2022-12-13 18:00:34 +00:00
|
|
|
auto [flakeRef, fragment] = parseFlakeRefWithFragment(std::string { prefix }, absPath("."));
|
2020-05-06 15:20:23 +00:00
|
|
|
result.push_back(std::make_shared<InstallableFlake>(
|
2021-02-17 16:32:10 +00:00
|
|
|
this,
|
|
|
|
getEvalState(),
|
|
|
|
std::move(flakeRef),
|
2022-02-14 19:39:44 +00:00
|
|
|
fragment,
|
2023-01-11 07:00:44 +00:00
|
|
|
extendedOutputsSpec,
|
2022-02-14 19:39:44 +00:00
|
|
|
getDefaultFlakeAttrPaths(),
|
2021-02-17 16:32:10 +00:00
|
|
|
getDefaultFlakeAttrPathPrefixes(),
|
|
|
|
lockFlags));
|
2020-05-06 15:20:23 +00:00
|
|
|
continue;
|
|
|
|
} catch (...) {
|
|
|
|
ex = std::current_exception();
|
2019-04-08 14:22:04 +00:00
|
|
|
}
|
2020-04-27 20:53:11 +00:00
|
|
|
|
2020-05-06 15:20:23 +00:00
|
|
|
std::rethrow_exception(ex);
|
2019-04-08 14:11:17 +00:00
|
|
|
}
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2017-04-25 09:20:37 +00:00
|
|
|
return result;
|
|
|
|
}
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
std::shared_ptr<Installable> SourceExprCommand::parseInstallable(
|
|
|
|
ref<Store> store, const std::string & installable)
|
2017-09-10 13:58:30 +00:00
|
|
|
{
|
2019-04-08 14:11:17 +00:00
|
|
|
auto installables = parseInstallables(store, {installable});
|
2017-09-10 13:58:30 +00:00
|
|
|
assert(installables.size() == 1);
|
|
|
|
return installables.front();
|
|
|
|
}
|
|
|
|
|
2022-11-21 09:49:01 +00:00
|
|
|
std::vector<BuiltPathWithResult> Installable::build(
|
2022-03-28 12:21:35 +00:00
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables,
|
|
|
|
BuildMode bMode)
|
2021-05-17 06:45:08 +00:00
|
|
|
{
|
2022-11-21 09:49:01 +00:00
|
|
|
std::vector<BuiltPathWithResult> res;
|
|
|
|
for (auto & [_, builtPathWithResult] : build2(evalStore, store, mode, installables, bMode))
|
|
|
|
res.push_back(builtPathWithResult);
|
2021-05-17 06:45:08 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2022-11-21 09:49:01 +00:00
|
|
|
std::vector<std::pair<std::shared_ptr<Installable>, BuiltPathWithResult>> Installable::build2(
|
2021-09-10 08:39:39 +00:00
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables,
|
|
|
|
BuildMode bMode)
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2020-07-15 18:05:42 +00:00
|
|
|
if (mode == Realise::Nothing)
|
2017-07-14 15:10:13 +00:00
|
|
|
settings.readOnlyMode = true;
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2022-12-15 21:09:32 +00:00
|
|
|
struct Aux
|
|
|
|
{
|
2023-01-10 13:52:49 +00:00
|
|
|
ExtraPathInfo info;
|
2022-12-15 21:09:32 +00:00
|
|
|
std::shared_ptr<Installable> installable;
|
|
|
|
};
|
|
|
|
|
2021-04-05 13:48:18 +00:00
|
|
|
std::vector<DerivedPath> pathsToBuild;
|
2022-12-15 21:09:32 +00:00
|
|
|
std::map<DerivedPath, std::vector<Aux>> backmap;
|
2017-07-14 15:10:13 +00:00
|
|
|
|
2017-09-06 14:03:22 +00:00
|
|
|
for (auto & i : installables) {
|
2022-03-28 12:21:35 +00:00
|
|
|
for (auto b : i->toDerivedPaths()) {
|
2022-12-15 21:09:32 +00:00
|
|
|
pathsToBuild.push_back(b.path);
|
|
|
|
backmap[b.path].push_back({.info = b.info, .installable = i});
|
2022-03-28 12:21:35 +00:00
|
|
|
}
|
2017-09-06 14:03:22 +00:00
|
|
|
}
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2022-11-21 09:49:01 +00:00
|
|
|
std::vector<std::pair<std::shared_ptr<Installable>, BuiltPathWithResult>> res;
|
2022-03-28 12:21:35 +00:00
|
|
|
|
2022-03-08 18:50:46 +00:00
|
|
|
switch (mode) {
|
2022-03-28 12:21:35 +00:00
|
|
|
|
2022-03-08 18:50:46 +00:00
|
|
|
case Realise::Nothing:
|
|
|
|
case Realise::Derivation:
|
2017-09-06 14:03:22 +00:00
|
|
|
printMissing(store, pathsToBuild, lvlError);
|
2022-03-28 12:21:35 +00:00
|
|
|
|
|
|
|
for (auto & path : pathsToBuild) {
|
2022-12-15 21:09:32 +00:00
|
|
|
for (auto & aux : backmap[path]) {
|
2022-03-28 12:21:35 +00:00
|
|
|
std::visit(overloaded {
|
|
|
|
[&](const DerivedPath::Built & bfd) {
|
2023-01-11 23:57:18 +00:00
|
|
|
auto outputs = resolveDerivedPath(*store, bfd, &*evalStore);
|
2022-12-15 21:09:32 +00:00
|
|
|
res.push_back({aux.installable, {
|
|
|
|
.path = BuiltPath::Built { bfd.drvPath, outputs },
|
|
|
|
.info = aux.info}});
|
2022-03-28 12:21:35 +00:00
|
|
|
},
|
|
|
|
[&](const DerivedPath::Opaque & bo) {
|
2022-12-15 21:09:32 +00:00
|
|
|
res.push_back({aux.installable, {
|
|
|
|
.path = BuiltPath::Opaque { bo.path },
|
|
|
|
.info = aux.info}});
|
2022-03-28 12:21:35 +00:00
|
|
|
},
|
|
|
|
}, path.raw());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2022-03-08 18:50:46 +00:00
|
|
|
case Realise::Outputs: {
|
2022-06-06 18:55:05 +00:00
|
|
|
if (settings.printMissing)
|
2022-11-18 12:40:48 +00:00
|
|
|
printMissing(store, pathsToBuild, lvlInfo);
|
2022-06-06 18:55:05 +00:00
|
|
|
|
2022-03-08 18:50:46 +00:00
|
|
|
for (auto & buildResult : store->buildPathsWithResults(pathsToBuild, bMode, evalStore)) {
|
|
|
|
if (!buildResult.success())
|
|
|
|
buildResult.rethrow();
|
2022-03-28 12:21:35 +00:00
|
|
|
|
2022-12-15 21:09:32 +00:00
|
|
|
for (auto & aux : backmap[buildResult.path]) {
|
2022-03-28 12:21:35 +00:00
|
|
|
std::visit(overloaded {
|
|
|
|
[&](const DerivedPath::Built & bfd) {
|
|
|
|
std::map<std::string, StorePath> outputs;
|
|
|
|
for (auto & path : buildResult.builtOutputs)
|
|
|
|
outputs.emplace(path.first.outputName, path.second.outPath);
|
2022-12-15 21:09:32 +00:00
|
|
|
res.push_back({aux.installable, {
|
|
|
|
.path = BuiltPath::Built { bfd.drvPath, outputs },
|
|
|
|
.info = aux.info,
|
|
|
|
.result = buildResult}});
|
2022-03-28 12:21:35 +00:00
|
|
|
},
|
|
|
|
[&](const DerivedPath::Opaque & bo) {
|
2022-12-15 21:09:32 +00:00
|
|
|
res.push_back({aux.installable, {
|
|
|
|
.path = BuiltPath::Opaque { bo.path },
|
|
|
|
.info = aux.info,
|
|
|
|
.result = buildResult}});
|
2022-03-28 12:21:35 +00:00
|
|
|
},
|
|
|
|
}, buildResult.path.raw());
|
|
|
|
}
|
2022-03-08 18:50:46 +00:00
|
|
|
}
|
2022-03-28 12:21:35 +00:00
|
|
|
|
|
|
|
break;
|
2022-03-08 18:50:46 +00:00
|
|
|
}
|
2022-03-28 12:21:35 +00:00
|
|
|
|
2022-03-08 18:50:46 +00:00
|
|
|
default:
|
|
|
|
assert(false);
|
|
|
|
}
|
2022-03-28 12:21:35 +00:00
|
|
|
|
|
|
|
return res;
|
2017-09-06 14:03:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-02 12:54:08 +00:00
|
|
|
BuiltPaths Installable::toBuiltPaths(
|
2021-07-16 14:04:47 +00:00
|
|
|
ref<Store> evalStore,
|
2020-12-14 16:24:30 +00:00
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
OperateOn operateOn,
|
2021-09-10 08:39:39 +00:00
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables)
|
2017-09-06 14:03:22 +00:00
|
|
|
{
|
2022-11-21 09:49:01 +00:00
|
|
|
if (operateOn == OperateOn::Output) {
|
|
|
|
BuiltPaths res;
|
|
|
|
for (auto & p : Installable::build(evalStore, store, mode, installables))
|
|
|
|
res.push_back(p.path);
|
|
|
|
return res;
|
|
|
|
} else {
|
2020-07-15 18:22:52 +00:00
|
|
|
if (mode == Realise::Nothing)
|
|
|
|
settings.readOnlyMode = true;
|
|
|
|
|
2021-05-17 06:45:08 +00:00
|
|
|
BuiltPaths res;
|
2022-03-02 12:54:08 +00:00
|
|
|
for (auto & drvPath : Installable::toDerivations(store, installables, true))
|
2021-05-17 06:45:08 +00:00
|
|
|
res.push_back(BuiltPath::Opaque{drvPath});
|
|
|
|
return res;
|
2020-07-15 18:22:52 +00:00
|
|
|
}
|
2020-12-14 16:24:30 +00:00
|
|
|
}
|
|
|
|
|
2022-03-02 12:54:08 +00:00
|
|
|
StorePathSet Installable::toStorePaths(
|
2021-07-16 14:04:47 +00:00
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
2020-12-14 16:24:30 +00:00
|
|
|
Realise mode, OperateOn operateOn,
|
2021-09-10 08:39:39 +00:00
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables)
|
2020-12-14 16:24:30 +00:00
|
|
|
{
|
|
|
|
StorePathSet outPaths;
|
2021-07-16 14:04:47 +00:00
|
|
|
for (auto & path : toBuiltPaths(evalStore, store, mode, operateOn, installables)) {
|
2021-05-17 06:45:08 +00:00
|
|
|
auto thisOutPaths = path.outPaths();
|
|
|
|
outPaths.insert(thisOutPaths.begin(), thisOutPaths.end());
|
|
|
|
}
|
2017-04-25 14:19:22 +00:00
|
|
|
return outPaths;
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
|
|
|
|
2022-03-02 12:54:08 +00:00
|
|
|
StorePath Installable::toStorePath(
|
2021-07-16 14:04:47 +00:00
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
2020-07-15 18:22:52 +00:00
|
|
|
Realise mode, OperateOn operateOn,
|
2017-09-10 13:58:30 +00:00
|
|
|
std::shared_ptr<Installable> installable)
|
|
|
|
{
|
2021-07-16 14:04:47 +00:00
|
|
|
auto paths = toStorePaths(evalStore, store, mode, operateOn, {installable});
|
2017-09-10 13:58:30 +00:00
|
|
|
|
|
|
|
if (paths.size() != 1)
|
2019-04-08 21:58:33 +00:00
|
|
|
throw Error("argument '%s' should evaluate to one store path", installable->what());
|
2017-09-10 13:58:30 +00:00
|
|
|
|
2020-06-16 20:20:18 +00:00
|
|
|
return *paths.begin();
|
2017-09-10 13:58:30 +00:00
|
|
|
}
|
|
|
|
|
2022-03-02 12:54:08 +00:00
|
|
|
StorePathSet Installable::toDerivations(
|
2021-09-10 08:39:39 +00:00
|
|
|
ref<Store> store,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables,
|
|
|
|
bool useDeriver)
|
Add "nix show-derivation"
This debug command prints a store derivation in JSON format. For
example:
$ nix show-derivation nixpkgs.hello
{
"/nix/store/ayjwpwwiyy04nh9z71rsdgd3q7bra7ch-hello-2.10.drv": {
"outputs": {
"out": {
"path": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10"
}
},
"inputSrcs": [
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"inputDrvs": {
"/nix/store/13839aqdf6x4k3b785rw5f2l7857l6y3-bash-4.4-p12.drv": [
"out"
],
"/nix/store/vgdx7fdc7d4iirmnwj2py1nrvr5qwzj7-hello-2.10.tar.gz.drv": [
"out"
],
"/nix/store/x3kkd0vsqfflbvwf1055l9mr39bg0ms0-stdenv.drv": [
"out"
]
},
"platform": "x86_64-linux",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"args": [
"-e",
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"env": {
"buildInputs": "",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"configureFlags": "",
"doCheck": "1",
"name": "hello-2.10",
"nativeBuildInputs": "",
"out": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10",
"propagatedBuildInputs": "",
"propagatedNativeBuildInputs": "",
"src": "/nix/store/3x7dwzq014bblazs7kq20p9hyzz0qh8g-hello-2.10.tar.gz",
"stdenv": "/nix/store/6zngq1rdh0ans9qyckqimqibgnlvlfrm-stdenv",
"system": "x86_64-linux"
}
}
}
This removes the need for pp-aterm.
2017-09-25 11:43:35 +00:00
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet drvPaths;
|
Add "nix show-derivation"
This debug command prints a store derivation in JSON format. For
example:
$ nix show-derivation nixpkgs.hello
{
"/nix/store/ayjwpwwiyy04nh9z71rsdgd3q7bra7ch-hello-2.10.drv": {
"outputs": {
"out": {
"path": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10"
}
},
"inputSrcs": [
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"inputDrvs": {
"/nix/store/13839aqdf6x4k3b785rw5f2l7857l6y3-bash-4.4-p12.drv": [
"out"
],
"/nix/store/vgdx7fdc7d4iirmnwj2py1nrvr5qwzj7-hello-2.10.tar.gz.drv": [
"out"
],
"/nix/store/x3kkd0vsqfflbvwf1055l9mr39bg0ms0-stdenv.drv": [
"out"
]
},
"platform": "x86_64-linux",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"args": [
"-e",
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"env": {
"buildInputs": "",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"configureFlags": "",
"doCheck": "1",
"name": "hello-2.10",
"nativeBuildInputs": "",
"out": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10",
"propagatedBuildInputs": "",
"propagatedNativeBuildInputs": "",
"src": "/nix/store/3x7dwzq014bblazs7kq20p9hyzz0qh8g-hello-2.10.tar.gz",
"stdenv": "/nix/store/6zngq1rdh0ans9qyckqimqibgnlvlfrm-stdenv",
"system": "x86_64-linux"
}
}
}
This removes the need for pp-aterm.
2017-09-25 11:43:35 +00:00
|
|
|
|
2021-09-30 21:31:21 +00:00
|
|
|
for (const auto & i : installables)
|
|
|
|
for (const auto & b : i->toDerivedPaths())
|
2020-07-23 19:02:57 +00:00
|
|
|
std::visit(overloaded {
|
2021-09-30 21:31:21 +00:00
|
|
|
[&](const DerivedPath::Opaque & bo) {
|
2020-07-23 19:02:57 +00:00
|
|
|
if (!useDeriver)
|
|
|
|
throw Error("argument '%s' did not evaluate to a derivation", i->what());
|
2022-01-18 16:28:18 +00:00
|
|
|
drvPaths.insert(getDeriver(store, *i, bo.path));
|
2020-07-23 19:02:57 +00:00
|
|
|
},
|
2021-09-30 21:31:21 +00:00
|
|
|
[&](const DerivedPath::Built & bfd) {
|
2020-07-23 19:02:57 +00:00
|
|
|
drvPaths.insert(bfd.drvPath);
|
|
|
|
},
|
2022-12-15 21:09:32 +00:00
|
|
|
}, b.path.raw());
|
Add "nix show-derivation"
This debug command prints a store derivation in JSON format. For
example:
$ nix show-derivation nixpkgs.hello
{
"/nix/store/ayjwpwwiyy04nh9z71rsdgd3q7bra7ch-hello-2.10.drv": {
"outputs": {
"out": {
"path": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10"
}
},
"inputSrcs": [
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"inputDrvs": {
"/nix/store/13839aqdf6x4k3b785rw5f2l7857l6y3-bash-4.4-p12.drv": [
"out"
],
"/nix/store/vgdx7fdc7d4iirmnwj2py1nrvr5qwzj7-hello-2.10.tar.gz.drv": [
"out"
],
"/nix/store/x3kkd0vsqfflbvwf1055l9mr39bg0ms0-stdenv.drv": [
"out"
]
},
"platform": "x86_64-linux",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"args": [
"-e",
"/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
],
"env": {
"buildInputs": "",
"builder": "/nix/store/qp5fw57d38bd1n07ss4zxh88zg67c3vg-bash-4.4-p12/bin/bash",
"configureFlags": "",
"doCheck": "1",
"name": "hello-2.10",
"nativeBuildInputs": "",
"out": "/nix/store/w5w4v29ql0qwqhczkdxs94ix2lh7ibgs-hello-2.10",
"propagatedBuildInputs": "",
"propagatedNativeBuildInputs": "",
"src": "/nix/store/3x7dwzq014bblazs7kq20p9hyzz0qh8g-hello-2.10.tar.gz",
"stdenv": "/nix/store/6zngq1rdh0ans9qyckqimqibgnlvlfrm-stdenv",
"system": "x86_64-linux"
}
}
}
This removes the need for pp-aterm.
2017-09-25 11:43:35 +00:00
|
|
|
|
|
|
|
return drvPaths;
|
|
|
|
}
|
|
|
|
|
2020-05-11 13:46:18 +00:00
|
|
|
InstallablesCommand::InstallablesCommand()
|
|
|
|
{
|
|
|
|
expectArgs({
|
|
|
|
.label = "installables",
|
|
|
|
.handler = {&_installables},
|
2020-05-11 19:49:02 +00:00
|
|
|
.completer = {[&](size_t, std::string_view prefix) {
|
|
|
|
completeInstallable(prefix);
|
|
|
|
}}
|
2020-05-11 13:46:18 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-04-25 10:06:32 +00:00
|
|
|
void InstallablesCommand::prepare()
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2022-03-11 18:26:08 +00:00
|
|
|
installables = load();
|
|
|
|
}
|
|
|
|
|
2023-02-04 03:02:39 +00:00
|
|
|
Installables InstallablesCommand::load()
|
|
|
|
{
|
2019-11-26 23:05:30 +00:00
|
|
|
if (_installables.empty() && useDefaultInstallables())
|
2022-03-26 10:32:37 +00:00
|
|
|
// FIXME: commands like "nix profile install" should not have a
|
2019-04-19 14:07:37 +00:00
|
|
|
// default, probably.
|
|
|
|
_installables.push_back(".");
|
2022-03-11 18:26:08 +00:00
|
|
|
return parseInstallables(getStore(), _installables);
|
2017-08-29 14:18:00 +00:00
|
|
|
}
|
|
|
|
|
2022-06-19 15:54:27 +00:00
|
|
|
std::vector<std::string> InstallablesCommand::getFlakesForCompletion()
|
2020-06-08 14:20:00 +00:00
|
|
|
{
|
2023-02-04 03:02:39 +00:00
|
|
|
if (_installables.empty() && useDefaultInstallables())
|
|
|
|
return {"."};
|
2022-06-19 15:54:27 +00:00
|
|
|
return _installables;
|
2020-06-08 14:20:00 +00:00
|
|
|
}
|
|
|
|
|
2023-02-05 01:45:40 +00:00
|
|
|
InstallableCommand::InstallableCommand()
|
|
|
|
: SourceExprCommand()
|
2020-05-11 19:49:02 +00:00
|
|
|
{
|
|
|
|
expectArgs({
|
|
|
|
.label = "installable",
|
2020-05-12 09:53:32 +00:00
|
|
|
.optional = true,
|
2020-05-11 19:49:02 +00:00
|
|
|
.handler = {&_installable},
|
|
|
|
.completer = {[&](size_t, std::string_view prefix) {
|
|
|
|
completeInstallable(prefix);
|
|
|
|
}}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-08-29 14:18:00 +00:00
|
|
|
void InstallableCommand::prepare()
|
|
|
|
{
|
2019-04-08 14:11:17 +00:00
|
|
|
installable = parseInstallable(getStore(), _installable);
|
2016-02-09 20:34:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|