2019-10-14 12:40:16 +00:00
|
|
|
#include "installables.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"
|
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
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
2019-05-22 11:46:07 +00:00
|
|
|
MixFlakeOptions::MixFlakeOptions()
|
2017-10-24 10:45:11 +00:00
|
|
|
{
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "recreate-lock-file",
|
|
|
|
.description = "recreate lock file from scratch",
|
|
|
|
.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",
|
|
|
|
.description = "do not allow any updates to the lock file",
|
|
|
|
.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",
|
|
|
|
.description = "do not write the newly generated lock file",
|
|
|
|
.handler = {&lockFlags.writeLockFile, false}
|
|
|
|
});
|
2019-05-14 09:34:45 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "no-registries",
|
|
|
|
.description = "don't use flake registries",
|
|
|
|
.handler = {&lockFlags.useRegistries, false}
|
|
|
|
});
|
2020-01-29 13:57:57 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "commit-lock-file",
|
|
|
|
.description = "commit changes to the lock file",
|
|
|
|
.handler = {&lockFlags.commitLockFile, true}
|
|
|
|
});
|
2020-02-05 13:48:49 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "update-input",
|
|
|
|
.description = "update a specific flake input",
|
|
|
|
.labels = {"input-path"},
|
|
|
|
.handler = {[&](std::string s) {
|
|
|
|
lockFlags.inputUpdates.insert(flake::parseInputPath(s));
|
|
|
|
}}
|
|
|
|
});
|
2020-01-29 22:12:58 +00:00
|
|
|
|
2020-05-05 16:59:33 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "override-input",
|
|
|
|
.description = "override a specific flake input (e.g. 'dwarffs/nixpkgs')",
|
|
|
|
.labels = {"input-path", "flake-url"},
|
|
|
|
.handler = {[&](std::string inputPath, std::string flakeRef) {
|
2020-01-29 13:57:57 +00:00
|
|
|
lockFlags.inputOverrides.insert_or_assign(
|
2020-05-05 16:59:33 +00:00
|
|
|
flake::parseInputPath(inputPath),
|
|
|
|
parseFlakeRef(flakeRef, absPath(".")));
|
|
|
|
}}
|
|
|
|
});
|
2019-05-22 11:46:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SourceExprCommand::SourceExprCommand()
|
|
|
|
{
|
2020-05-04 20:40:19 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "file",
|
|
|
|
.shortName = 'f',
|
|
|
|
.description = "evaluate FILE rather than the default",
|
|
|
|
.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({
|
|
|
|
.longName ="expr",
|
|
|
|
.description = "evaluate attributes from EXPR",
|
|
|
|
.labels = {"expr"},
|
|
|
|
.handler = {&expr}
|
|
|
|
});
|
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()
|
|
|
|
{
|
|
|
|
return {"defaultPackage." + settings.thisSystem.get()};
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
if (file) return; // FIXME
|
|
|
|
|
|
|
|
/* Look for flake output attributes that match the
|
|
|
|
prefix. */
|
|
|
|
try {
|
|
|
|
auto hash = prefix.find('#');
|
|
|
|
if (hash != std::string::npos) {
|
|
|
|
auto fragment = prefix.substr(hash + 1);
|
|
|
|
auto flakeRefS = std::string(prefix.substr(0, hash));
|
|
|
|
// FIXME: do tilde expansion.
|
|
|
|
auto flakeRef = parseFlakeRef(flakeRefS, absPath("."));
|
|
|
|
|
|
|
|
auto state = getEvalState();
|
|
|
|
|
|
|
|
auto evalCache = openEvalCache(*state,
|
|
|
|
std::make_shared<flake::LockedFlake>(lockFlake(*state, flakeRef, lockFlags)),
|
|
|
|
true);
|
|
|
|
|
|
|
|
auto root = evalCache->getRoot();
|
|
|
|
|
|
|
|
/* Complete 'fragment' relative to all the
|
|
|
|
attrpath prefixes as well as the root of the
|
|
|
|
flake. */
|
|
|
|
auto attrPathPrefixes = getDefaultFlakeAttrPathPrefixes();
|
|
|
|
attrPathPrefixes.push_back("");
|
|
|
|
|
|
|
|
for (auto & attrPathPrefixS : attrPathPrefixes) {
|
|
|
|
auto attrPathPrefix = parseAttrPath(*state, attrPathPrefixS);
|
|
|
|
auto attrPathS = attrPathPrefixS + std::string(fragment);
|
|
|
|
auto attrPath = parseAttrPath(*state, attrPathS);
|
|
|
|
|
|
|
|
std::string lastAttr;
|
|
|
|
if (!attrPath.empty() && !hasSuffix(attrPathS, ".")) {
|
|
|
|
lastAttr = attrPath.back();
|
|
|
|
attrPath.pop_back();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto attr = root->findAlongAttrPath(attrPath);
|
|
|
|
if (!attr) continue;
|
|
|
|
|
|
|
|
auto attrs = attr->getAttrs();
|
|
|
|
for (auto & attr2 : attrs) {
|
|
|
|
if (hasPrefix(attr2, lastAttr)) {
|
|
|
|
auto attrPath2 = attr->getAttrPath(attr2);
|
|
|
|
/* Strip the attrpath prefix. */
|
|
|
|
attrPath2.erase(attrPath2.begin(), attrPath2.begin() + attrPathPrefix.size());
|
|
|
|
completions->insert(flakeRefS + "#" + concatStringsSep(".", attrPath2));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And add an empty completion for the default
|
|
|
|
attrpaths. */
|
|
|
|
if (fragment.empty()) {
|
|
|
|
for (auto & attrPath : getDefaultFlakeAttrPaths()) {
|
|
|
|
auto attr = root->findAlongAttrPath(parseAttrPath(*state, attrPath));
|
|
|
|
if (!attr) continue;
|
|
|
|
completions->insert(flakeRefS + "#");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} catch (Error & e) {
|
|
|
|
warn(e.msg());
|
|
|
|
}
|
|
|
|
|
2020-05-11 20:10:33 +00:00
|
|
|
completeFlakeRef(prefix);
|
|
|
|
}
|
|
|
|
|
|
|
|
ref<EvalState> EvalCommand::getEvalState()
|
|
|
|
{
|
|
|
|
if (!evalState)
|
|
|
|
evalState = std::make_shared<EvalState>(searchPath, getStore());
|
|
|
|
return ref<EvalState>(evalState);
|
|
|
|
}
|
|
|
|
|
|
|
|
void EvalCommand::completeFlakeRef(std::string_view prefix)
|
|
|
|
{
|
|
|
|
if (prefix == "")
|
|
|
|
completions->insert(".");
|
|
|
|
|
|
|
|
completeDir(0, prefix);
|
|
|
|
|
2020-05-11 19:49:02 +00:00
|
|
|
/* Look for registry entries that match the prefix. */
|
|
|
|
for (auto & registry : fetchers::getRegistries(getStore())) {
|
|
|
|
for (auto & entry : registry->entries) {
|
|
|
|
auto from = entry.from->to_string();
|
|
|
|
if (!hasPrefix(prefix, "flake:") && hasPrefix(from, "flake:")) {
|
|
|
|
std::string from2(from, 6);
|
|
|
|
if (hasPrefix(from2, prefix))
|
|
|
|
completions->insert(from2);
|
|
|
|
} else {
|
|
|
|
if (hasPrefix(from, prefix))
|
|
|
|
completions->insert(from);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-06 14:03:22 +00:00
|
|
|
Buildable Installable::toBuildable()
|
|
|
|
{
|
|
|
|
auto buildables = toBuildables();
|
|
|
|
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]);
|
|
|
|
}
|
|
|
|
|
2019-06-17 15:59:57 +00:00
|
|
|
App::App(EvalState & state, Value & vApp)
|
2019-05-31 21:45:13 +00:00
|
|
|
{
|
2019-06-17 15:59:57 +00:00
|
|
|
state.forceAttrs(vApp);
|
2019-05-31 21:45:13 +00:00
|
|
|
|
2019-06-17 15:59:57 +00:00
|
|
|
auto aType = vApp.attrs->need(state.sType);
|
2019-05-31 21:45:13 +00:00
|
|
|
if (state.forceStringNoCtx(*aType.value, *aType.pos) != "app")
|
|
|
|
throw Error("value does not have type 'app', at %s", *aType.pos);
|
|
|
|
|
2019-06-17 15:59:57 +00:00
|
|
|
auto aProgram = vApp.attrs->need(state.symbols.create("program"));
|
|
|
|
program = state.forceString(*aProgram.value, context, *aProgram.pos);
|
2019-05-31 21:45:13 +00:00
|
|
|
|
|
|
|
// FIXME: check that 'program' is in the closure of 'context'.
|
2019-06-17 15:59:57 +00:00
|
|
|
if (!state.store->isInStore(program))
|
|
|
|
throw Error("app program '%s' is not in the Nix store", program);
|
|
|
|
}
|
2019-05-31 21:45:13 +00:00
|
|
|
|
2019-06-17 15:59:57 +00:00
|
|
|
App Installable::toApp(EvalState & state)
|
|
|
|
{
|
2020-02-07 13:22:01 +00:00
|
|
|
return App(state, *toValue(state).first);
|
2019-05-31 21:45:13 +00:00
|
|
|
}
|
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>>
|
|
|
|
Installable::getCursor(EvalState & state, bool useEvalCache)
|
|
|
|
{
|
|
|
|
auto evalCache =
|
|
|
|
std::make_shared<nix::eval_cache::EvalCache>(false, Hash(), state,
|
|
|
|
[&]() { return toValue(state).first; });
|
|
|
|
return {{evalCache->getRoot(), ""}};
|
|
|
|
}
|
|
|
|
|
2017-04-25 09:20:37 +00:00
|
|
|
struct InstallableStorePath : Installable
|
2016-02-09 20:34:24 +00:00
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
ref<Store> store;
|
|
|
|
StorePath storePath;
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
InstallableStorePath(ref<Store> store, const Path & storePath)
|
|
|
|
: store(store), storePath(store->parseStorePath(storePath)) { }
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
std::string what() override { return store->printStorePath(storePath); }
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2017-09-06 14:03:22 +00:00
|
|
|
Buildables toBuildables() override
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
std::map<std::string, StorePath> outputs;
|
|
|
|
outputs.insert_or_assign("out", storePath.clone());
|
|
|
|
Buildable b{
|
|
|
|
.drvPath = storePath.isDerivation() ? storePath.clone() : std::optional<StorePath>(),
|
|
|
|
.outputs = std::move(outputs)
|
|
|
|
};
|
|
|
|
Buildables bs;
|
|
|
|
bs.push_back(std::move(b));
|
|
|
|
return bs;
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
2019-07-12 14:28:39 +00:00
|
|
|
|
2019-12-11 13:53:30 +00:00
|
|
|
std::optional<StorePath> getStorePath() override
|
2019-07-12 14:28:39 +00:00
|
|
|
{
|
2019-12-11 13:53:30 +00:00
|
|
|
return storePath.clone();
|
2019-07-12 14:28:39 +00:00
|
|
|
}
|
2017-04-25 09:20:37 +00:00
|
|
|
};
|
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
std::vector<InstallableValue::DerivationInfo> InstallableValue::toDerivations()
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2019-10-14 12:40:16 +00:00
|
|
|
auto state = cmd.getEvalState();
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2020-02-07 13:22:01 +00:00
|
|
|
auto v = toValue(*state).first;
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
Bindings & autoArgs = *cmd.getAutoArgs(*state);
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
DrvInfos drvInfos;
|
|
|
|
getDerivations(*state, *v, "", autoArgs, drvInfos, false);
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
std::vector<DerivationInfo> res;
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & drvInfo : drvInfos) {
|
|
|
|
res.push_back({
|
2019-12-11 13:53:30 +00:00
|
|
|
state->store->parseStorePath(drvInfo.queryDrvPath()),
|
|
|
|
state->store->parseStorePath(drvInfo.queryOutPath()),
|
2019-10-14 12:40:16 +00:00
|
|
|
drvInfo.queryOutputName()
|
|
|
|
});
|
2019-06-07 20:25:48 +00:00
|
|
|
}
|
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
return res;
|
|
|
|
}
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
Buildables InstallableValue::toBuildables()
|
|
|
|
{
|
2019-12-11 13:53:30 +00:00
|
|
|
auto state = cmd.getEvalState();
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
Buildables res;
|
2017-09-06 14:03:22 +00:00
|
|
|
|
2019-12-11 13:53:30 +00:00
|
|
|
StorePathSet drvPaths;
|
2017-09-06 14:03:22 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & drv : toDerivations()) {
|
2019-12-11 13:53:30 +00:00
|
|
|
Buildable b{.drvPath = drv.drvPath.clone()};
|
|
|
|
drvPaths.insert(drv.drvPath.clone());
|
2017-09-06 14:03:22 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
auto outputName = drv.outputName;
|
|
|
|
if (outputName == "")
|
2019-12-11 13:53:30 +00:00
|
|
|
throw Error("derivation '%s' lacks an 'outputName' attribute", state->store->printStorePath(*b.drvPath));
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2019-12-11 13:53:30 +00:00
|
|
|
b.outputs.emplace(outputName, drv.outPath.clone());
|
2017-09-06 14:03:22 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
res.push_back(std::move(b));
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
2019-10-14 12:40:16 +00:00
|
|
|
|
|
|
|
// Hack to recognize .all: if all drvs have the same drvPath,
|
|
|
|
// merge the buildables.
|
|
|
|
if (drvPaths.size() == 1) {
|
2019-12-11 13:53:30 +00:00
|
|
|
Buildable b{.drvPath = drvPaths.begin()->clone()};
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & b2 : res)
|
2019-12-11 13:53:30 +00:00
|
|
|
for (auto & output : b2.outputs)
|
|
|
|
b.outputs.insert_or_assign(output.first, output.second.clone());
|
|
|
|
Buildables bs;
|
|
|
|
bs.push_back(std::move(b));
|
|
|
|
return bs;
|
2019-10-14 12:40:16 +00:00
|
|
|
} else
|
|
|
|
return res;
|
|
|
|
}
|
2017-08-29 14:18:00 +00:00
|
|
|
|
|
|
|
struct InstallableExpr : InstallableValue
|
|
|
|
{
|
|
|
|
std::string text;
|
|
|
|
|
|
|
|
InstallableExpr(SourceExprCommand & cmd, const std::string & text)
|
|
|
|
: InstallableValue(cmd), text(text) { }
|
|
|
|
|
|
|
|
std::string what() override { return text; }
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2020-02-07 13:22:01 +00:00
|
|
|
std::pair<Value *, Pos> toValue(EvalState & state) override
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
|
|
|
auto v = state.allocValue();
|
|
|
|
state.eval(state.parseExprFromString(text, absPath(".")), *v);
|
2020-02-07 13:22:01 +00:00
|
|
|
return {v, noPos};
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-08-29 14:18:00 +00:00
|
|
|
struct InstallableAttrPath : InstallableValue
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2020-04-16 14:54:34 +00:00
|
|
|
RootValue v;
|
2017-04-25 09:20:37 +00:00
|
|
|
std::string attrPath;
|
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
InstallableAttrPath(SourceExprCommand & cmd, Value * v, const std::string & attrPath)
|
2020-04-16 14:54:34 +00:00
|
|
|
: InstallableValue(cmd), v(allocRootValue(v)), attrPath(attrPath)
|
2017-04-25 09:20:37 +00:00
|
|
|
{ }
|
|
|
|
|
|
|
|
std::string what() override { return attrPath; }
|
|
|
|
|
2020-02-07 13:22:01 +00:00
|
|
|
std::pair<Value *, Pos> toValue(EvalState & state) override
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2020-04-16 14:54:34 +00:00
|
|
|
auto [vRes, pos] = findAlongAttrPath(state, attrPath, *cmd.getAutoArgs(state), **v);
|
2019-04-08 14:11:17 +00:00
|
|
|
state.forceValue(*vRes);
|
2020-02-07 13:22:01 +00:00
|
|
|
return {vRes, pos};
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
std::vector<std::string> InstallableFlake::getActualAttrPaths()
|
2019-04-08 12:21:13 +00:00
|
|
|
{
|
2019-10-14 12:40:16 +00:00
|
|
|
std::vector<std::string> res;
|
2019-05-01 09:38:48 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & prefix : prefixes)
|
|
|
|
res.push_back(prefix + *attrPaths.begin());
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & s : attrPaths)
|
|
|
|
res.push_back(s);
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
return res;
|
|
|
|
}
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2020-01-22 19:59:59 +00:00
|
|
|
Value * InstallableFlake::getFlakeOutputs(EvalState & state, const flake::LockedFlake & lockedFlake)
|
2019-10-14 12:40:16 +00:00
|
|
|
{
|
|
|
|
auto vFlake = state.allocValue();
|
2019-05-23 21:42:13 +00:00
|
|
|
|
2020-01-22 19:59:59 +00:00
|
|
|
callFlake(state, lockedFlake, *vFlake);
|
2019-05-23 21:42:13 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
auto aOutputs = vFlake->attrs->get(state.symbols.create("outputs"));
|
|
|
|
assert(aOutputs);
|
2019-04-08 12:21:13 +00:00
|
|
|
|
2020-02-14 21:45:33 +00:00
|
|
|
state.forceValue(*aOutputs->value);
|
2019-04-08 12:21:13 +00:00
|
|
|
|
2020-02-14 21:45:33 +00:00
|
|
|
return aOutputs->value;
|
2019-10-14 12:40:16 +00:00
|
|
|
}
|
2019-04-08 12:21:13 +00:00
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
ref<eval_cache::EvalCache> openEvalCache(
|
|
|
|
EvalState & state,
|
2020-04-20 13:27:09 +00:00
|
|
|
std::shared_ptr<flake::LockedFlake> lockedFlake,
|
2020-04-20 11:13:52 +00:00
|
|
|
bool useEvalCache)
|
|
|
|
{
|
|
|
|
return ref(std::make_shared<nix::eval_cache::EvalCache>(
|
|
|
|
useEvalCache,
|
2020-04-20 13:27:09 +00:00
|
|
|
lockedFlake->getFingerprint(),
|
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
|
|
|
|
|
|
|
state.forceAttrs(*vFlake);
|
|
|
|
|
|
|
|
auto aOutputs = vFlake->attrs->get(state.symbols.create("outputs"));
|
|
|
|
assert(aOutputs);
|
|
|
|
|
|
|
|
return aOutputs->value;
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
std::tuple<std::string, FlakeRef, InstallableValue::DerivationInfo> InstallableFlake::toDerivation()
|
2019-10-14 12:40:16 +00:00
|
|
|
{
|
|
|
|
auto state = cmd.getEvalState();
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
auto lockedFlake = std::make_shared<flake::LockedFlake>(
|
|
|
|
lockFlake(*state, flakeRef, cmd.lockFlags));
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
auto cache = openEvalCache(*state, lockedFlake, true);
|
|
|
|
auto root = cache->getRoot();
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & attrPath : getActualAttrPaths()) {
|
2020-04-20 11:13:52 +00:00
|
|
|
auto attr = root->findAlongAttrPath(parseAttrPath(*state, attrPath));
|
|
|
|
if (!attr) continue;
|
|
|
|
|
|
|
|
if (!attr->isDerivation())
|
|
|
|
throw Error("flake output attribute '%s' is not a derivation", attrPath);
|
|
|
|
|
|
|
|
auto aDrvPath = attr->getAttr(state->sDrvPath);
|
|
|
|
auto drvPath = state->store->parseStorePath(aDrvPath->getString());
|
2020-04-29 13:42:53 +00:00
|
|
|
if (!state->store->isValidPath(drvPath) && !settings.readOnlyMode) {
|
2020-04-20 11:13:52 +00:00
|
|
|
/* The eval cache contains 'drvPath', but the actual path
|
|
|
|
has been garbage-collected. So force it to be
|
|
|
|
regenerated. */
|
|
|
|
aDrvPath->forceValue();
|
2020-04-29 13:42:53 +00:00
|
|
|
if (!state->store->isValidPath(drvPath))
|
|
|
|
throw Error("don't know how to recreate store derivation '%s'!",
|
|
|
|
state->store->printStorePath(drvPath));
|
2019-10-14 12:40:16 +00:00
|
|
|
}
|
2019-05-29 19:30:22 +00:00
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
auto drvInfo = DerivationInfo{
|
|
|
|
std::move(drvPath),
|
|
|
|
state->store->parseStorePath(attr->getAttr(state->sOutPath)->getString()),
|
|
|
|
attr->getAttr(state->sOutputName)->getString()
|
|
|
|
};
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
return {attrPath, lockedFlake->flake.lockedRef, std::move(drvInfo)};
|
2019-06-07 20:25:48 +00:00
|
|
|
}
|
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
throw Error("flake '%s' does not provide attribute %s",
|
|
|
|
flakeRef, concatStringsSep(", ", quoteStrings(attrPaths)));
|
|
|
|
}
|
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
std::vector<InstallableValue::DerivationInfo> InstallableFlake::toDerivations()
|
2019-10-21 22:21:58 +00:00
|
|
|
{
|
2020-04-20 11:13:52 +00:00
|
|
|
std::vector<DerivationInfo> res;
|
2019-12-11 13:53:30 +00:00
|
|
|
res.push_back(std::get<2>(toDerivation()));
|
|
|
|
return res;
|
2019-10-21 22:21:58 +00:00
|
|
|
}
|
|
|
|
|
2020-02-07 13:22:01 +00:00
|
|
|
std::pair<Value *, Pos> InstallableFlake::toValue(EvalState & state)
|
2019-10-14 12:40:16 +00:00
|
|
|
{
|
2020-01-29 20:01:34 +00:00
|
|
|
auto lockedFlake = lockFlake(state, flakeRef, cmd.lockFlags);
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2020-01-22 19:59:59 +00:00
|
|
|
auto vOutputs = getFlakeOutputs(state, lockedFlake);
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
auto emptyArgs = state.allocBindings(0);
|
2019-06-07 20:25:48 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
for (auto & attrPath : getActualAttrPaths()) {
|
|
|
|
try {
|
2020-02-07 13:22:01 +00:00
|
|
|
auto [v, pos] = findAlongAttrPath(state, attrPath, *emptyArgs, *vOutputs);
|
2019-10-14 12:40:16 +00:00
|
|
|
state.forceValue(*v);
|
2020-02-07 13:22:01 +00:00
|
|
|
return {v, pos};
|
2019-10-14 12:40:16 +00:00
|
|
|
} catch (AttrPathNotFound & e) {
|
2019-04-08 12:21:13 +00:00
|
|
|
}
|
|
|
|
}
|
2019-10-14 12:40:16 +00:00
|
|
|
|
|
|
|
throw Error("flake '%s' does not provide attribute %s",
|
|
|
|
flakeRef, concatStringsSep(", ", quoteStrings(attrPaths)));
|
|
|
|
}
|
2019-04-08 12:21:13 +00:00
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>>
|
|
|
|
InstallableFlake::getCursor(EvalState & state, bool useEvalCache)
|
|
|
|
{
|
|
|
|
auto evalCache = openEvalCache(state,
|
|
|
|
std::make_shared<flake::LockedFlake>(lockFlake(state, flakeRef, cmd.lockFlags)),
|
|
|
|
useEvalCache);
|
|
|
|
|
|
|
|
auto root = evalCache->getRoot();
|
|
|
|
|
|
|
|
std::vector<std::pair<std::shared_ptr<eval_cache::AttrCursor>, std::string>> res;
|
|
|
|
|
|
|
|
for (auto & attrPath : getActualAttrPaths()) {
|
|
|
|
auto attr = root->findAlongAttrPath(parseAttrPath(state, attrPath));
|
|
|
|
if (attr) res.push_back({attr, attrPath});
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2019-11-26 23:05:30 +00:00
|
|
|
if (file)
|
|
|
|
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
|
|
|
|
2019-04-08 14:11:17 +00:00
|
|
|
for (auto & s : ss)
|
2019-11-26 23:05:30 +00:00
|
|
|
result.push_back(std::make_shared<InstallableAttrPath>(*this, vFile, s == "." ? "" : s));
|
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;
|
|
|
|
|
|
|
|
try {
|
|
|
|
auto [flakeRef, fragment] = parseFlakeRefWithFragment(s, absPath("."));
|
|
|
|
result.push_back(std::make_shared<InstallableFlake>(
|
|
|
|
*this, std::move(flakeRef),
|
|
|
|
fragment == "" ? getDefaultFlakeAttrPaths() : Strings{fragment},
|
|
|
|
getDefaultFlakeAttrPathPrefixes()));
|
|
|
|
continue;
|
|
|
|
} catch (...) {
|
|
|
|
ex = std::current_exception();
|
2019-04-08 14:22:04 +00:00
|
|
|
}
|
|
|
|
|
2020-05-06 15:20:23 +00:00
|
|
|
if (s.find('/') != std::string::npos) {
|
2020-04-27 20:53:11 +00:00
|
|
|
try {
|
2020-05-06 15:20:23 +00:00
|
|
|
result.push_back(std::make_shared<InstallableStorePath>(store, store->printStorePath(store->followLinksToStorePath(s))));
|
2020-04-27 20:53:11 +00:00
|
|
|
continue;
|
2020-05-06 15:20:23 +00:00
|
|
|
} catch (NotInStore &) {
|
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
|
|
|
std::rethrow_exception(ex);
|
2020-04-27 20:53:11 +00:00
|
|
|
|
2020-05-06 15:20:23 +00:00
|
|
|
/*
|
|
|
|
throw Error(
|
|
|
|
pathExists(s)
|
|
|
|
? "path '%s' is not a flake or a store path"
|
|
|
|
: "don't know how to handle argument '%s'", s);
|
|
|
|
*/
|
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();
|
|
|
|
}
|
|
|
|
|
2018-02-09 15:42:32 +00:00
|
|
|
Buildables build(ref<Store> store, RealiseMode mode,
|
2017-09-10 13:58:30 +00:00
|
|
|
std::vector<std::shared_ptr<Installable>> installables)
|
2017-04-25 09:20:37 +00:00
|
|
|
{
|
2017-08-14 18:14:55 +00:00
|
|
|
if (mode != Build)
|
2017-07-14 15:10:13 +00:00
|
|
|
settings.readOnlyMode = true;
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2017-09-06 14:03:22 +00:00
|
|
|
Buildables buildables;
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
std::vector<StorePathWithOutputs> pathsToBuild;
|
2017-07-14 15:10:13 +00:00
|
|
|
|
2017-09-06 14:03:22 +00:00
|
|
|
for (auto & i : installables) {
|
|
|
|
for (auto & b : i->toBuildables()) {
|
2019-12-05 18:11:09 +00:00
|
|
|
if (b.drvPath) {
|
2017-09-10 13:58:30 +00:00
|
|
|
StringSet outputNames;
|
|
|
|
for (auto & output : b.outputs)
|
|
|
|
outputNames.insert(output.first);
|
2019-12-05 18:11:09 +00:00
|
|
|
pathsToBuild.push_back({*b.drvPath, outputNames});
|
2017-09-27 11:14:45 +00:00
|
|
|
} else
|
|
|
|
for (auto & output : b.outputs)
|
2019-12-05 18:11:09 +00:00
|
|
|
pathsToBuild.push_back({output.second.clone()});
|
2017-09-06 14:03:22 +00:00
|
|
|
buildables.push_back(std::move(b));
|
2017-07-14 15:10:13 +00:00
|
|
|
}
|
2017-09-06 14:03:22 +00:00
|
|
|
}
|
2016-02-09 20:34:24 +00:00
|
|
|
|
2017-07-14 12:23:38 +00:00
|
|
|
if (mode == DryRun)
|
2017-09-06 14:03:22 +00:00
|
|
|
printMissing(store, pathsToBuild, lvlError);
|
2017-07-14 12:23:38 +00:00
|
|
|
else if (mode == Build)
|
2017-09-06 14:03:22 +00:00
|
|
|
store->buildPaths(pathsToBuild);
|
|
|
|
|
|
|
|
return buildables;
|
|
|
|
}
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet toStorePaths(ref<Store> store, RealiseMode mode,
|
2017-09-10 13:58:30 +00:00
|
|
|
std::vector<std::shared_ptr<Installable>> installables)
|
2017-09-06 14:03:22 +00:00
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet outPaths;
|
2017-09-06 14:03:22 +00:00
|
|
|
|
2018-02-09 15:42:32 +00:00
|
|
|
for (auto & b : build(store, mode, installables))
|
2017-09-06 14:03:22 +00:00
|
|
|
for (auto & output : b.outputs)
|
2019-12-05 18:11:09 +00:00
|
|
|
outPaths.insert(output.second.clone());
|
2017-04-25 09:20:37 +00:00
|
|
|
|
2017-04-25 14:19:22 +00:00
|
|
|
return outPaths;
|
2017-04-25 09:20:37 +00:00
|
|
|
}
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePath toStorePath(ref<Store> store, RealiseMode mode,
|
2017-09-10 13:58:30 +00:00
|
|
|
std::shared_ptr<Installable> installable)
|
|
|
|
{
|
|
|
|
auto paths = toStorePaths(store, mode, {installable});
|
|
|
|
|
|
|
|
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
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
return paths.begin()->clone();
|
2017-09-10 13:58:30 +00:00
|
|
|
}
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet toDerivations(ref<Store> store,
|
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
|
|
|
std::vector<std::shared_ptr<Installable>> installables, bool useDeriver)
|
|
|
|
{
|
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
|
|
|
|
|
|
|
for (auto & i : installables)
|
|
|
|
for (auto & b : i->toBuildables()) {
|
2019-12-05 18:11:09 +00:00
|
|
|
if (!b.drvPath) {
|
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
|
|
|
if (!useDeriver)
|
|
|
|
throw Error("argument '%s' did not evaluate to a derivation", i->what());
|
|
|
|
for (auto & output : b.outputs) {
|
|
|
|
auto derivers = store->queryValidDerivers(output.second);
|
|
|
|
if (derivers.empty())
|
|
|
|
throw Error("'%s' does not have a known deriver", i->what());
|
|
|
|
// FIXME: use all derivers?
|
2019-12-05 18:11:09 +00:00
|
|
|
drvPaths.insert(derivers.begin()->clone());
|
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
|
|
|
}
|
|
|
|
} else
|
2019-12-05 18:11:09 +00:00
|
|
|
drvPaths.insert(b.drvPath->clone());
|
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
|
|
|
{
|
2019-11-26 23:05:30 +00:00
|
|
|
if (_installables.empty() && useDefaultInstallables())
|
2019-04-19 14:07:37 +00:00
|
|
|
// FIXME: commands like "nix install" should not have a
|
|
|
|
// default, probably.
|
|
|
|
_installables.push_back(".");
|
2019-04-08 14:11:17 +00:00
|
|
|
installables = parseInstallables(getStore(), _installables);
|
2017-08-29 14:18:00 +00:00
|
|
|
}
|
|
|
|
|
2020-05-11 19:49:02 +00:00
|
|
|
InstallableCommand::InstallableCommand()
|
|
|
|
{
|
|
|
|
expectArgs({
|
|
|
|
.label = "installable",
|
|
|
|
.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
|
|
|
}
|
|
|
|
|
|
|
|
}
|