lix/src/nix/installables.cc

587 lines
18 KiB
C++
Raw Normal View History

2019-10-14 12:40:16 +00:00
#include "installables.hh"
2017-04-25 10:06:32 +00:00
#include "command.hh"
#include "attr-path.hh"
#include "common-eval-args.hh"
#include "derivations.hh"
#include "eval-inline.hh"
#include "eval.hh"
#include "get-drvs.hh"
#include "store-api.hh"
#include "shared.hh"
#include "flake/flake.hh"
#include "flake/eval-cache.hh"
#include "fetchers/parse.hh"
#include <regex>
#include <queue>
namespace nix {
MixFlakeOptions::MixFlakeOptions()
{
mkFlag()
2019-05-01 09:38:48 +00:00
.longName("recreate-lock-file")
.description("recreate lock file from scratch")
.set(&lockFlags.recreateLockFile, true);
mkFlag()
.longName("no-update-lock-file")
.description("do not allow any updates to the lock file")
.set(&lockFlags.updateLockFile, false);
mkFlag()
.longName("no-write-lock-file")
.description("do not write the newly generated lock file")
.set(&lockFlags.writeLockFile, false);
mkFlag()
.longName("no-registries")
.description("don't use flake registries")
.set(&lockFlags.useRegistries, false);
2020-02-05 13:48:49 +00:00
mkFlag()
.longName("commit-lock-file")
.description("commit changes to the lock file")
.set(&lockFlags.commitLockFile, true);
mkFlag()
.longName("update-input")
.description("update a specific flake input")
.label("input-path")
.handler([&](std::vector<std::string> ss) {
lockFlags.inputUpdates.insert(flake::parseInputPath(ss[0]));
});
mkFlag()
.longName("override-input")
.description("override a specific flake input (e.g. 'dwarffs/nixpkgs')")
.arity(2)
.labels({"input-path", "flake-url"})
.handler([&](std::vector<std::string> ss) {
lockFlags.inputOverrides.insert_or_assign(
flake::parseInputPath(ss[0]),
parseFlakeRef(ss[1], absPath(".")));
});
}
SourceExprCommand::SourceExprCommand()
{
mkFlag()
.shortName('f')
.longName("file")
.label("file")
.description("evaluate attributes from FILE")
.dest(&file);
mkFlag()
.longName("expr")
.label("expr")
.description("evaluate attributes from EXPR")
.dest(&expr);
}
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() + "."
};
}
ref<EvalState> EvalCommand::getEvalState()
2017-07-17 17:02:56 +00:00
{
if (!evalState)
evalState = std::make_shared<EvalState>(searchPath, getStore());
2017-07-17 17:02:56 +00:00
return ref<EvalState>(evalState);
}
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-06-17 15:59:57 +00:00
state.forceAttrs(vApp);
2019-06-17 15:59:57 +00:00
auto aType = vApp.attrs->need(state.sType);
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);
// 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-06-17 15:59:57 +00:00
App Installable::toApp(EvalState & state)
{
return App(state, *toValue(state).first);
}
struct InstallableStorePath : Installable
{
ref<Store> store;
StorePath storePath;
InstallableStorePath(ref<Store> store, const Path & storePath)
: store(store), storePath(store->parseStorePath(storePath)) { }
std::string what() override { return store->printStorePath(storePath); }
2017-09-06 14:03:22 +00:00
Buildables toBuildables() override
{
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;
}
std::optional<StorePath> getStorePath() override
{
return storePath.clone();
}
};
2019-10-14 12:40:16 +00:00
std::vector<flake::EvalCache::Derivation> InstallableValue::toDerivations()
{
2019-10-14 12:40:16 +00:00
auto state = cmd.getEvalState();
auto v = toValue(*state).first;
2019-10-14 12:40:16 +00:00
Bindings & autoArgs = *cmd.getAutoArgs(*state);
2019-10-14 12:40:16 +00:00
DrvInfos drvInfos;
getDerivations(*state, *v, "", autoArgs, drvInfos, false);
2019-10-14 12:40:16 +00:00
std::vector<flake::EvalCache::Derivation> res;
for (auto & drvInfo : drvInfos) {
res.push_back({
state->store->parseStorePath(drvInfo.queryDrvPath()),
state->store->parseStorePath(drvInfo.queryOutPath()),
2019-10-14 12:40:16 +00:00
drvInfo.queryOutputName()
});
}
2019-10-14 12:40:16 +00:00
return res;
}
2019-10-14 12:40:16 +00:00
Buildables InstallableValue::toBuildables()
{
auto state = cmd.getEvalState();
2019-10-14 12:40:16 +00:00
Buildables res;
2017-09-06 14:03:22 +00:00
StorePathSet drvPaths;
2017-09-06 14:03:22 +00:00
2019-10-14 12:40:16 +00:00
for (auto & drv : toDerivations()) {
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 == "")
throw Error("derivation '%s' lacks an 'outputName' attribute", state->store->printStorePath(*b.drvPath));
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));
}
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) {
Buildable b{.drvPath = drvPaths.begin()->clone()};
2019-10-14 12:40:16 +00:00
for (auto & b2 : res)
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;
}
struct InstallableExpr : InstallableValue
{
std::string text;
InstallableExpr(SourceExprCommand & cmd, const std::string & text)
: InstallableValue(cmd), text(text) { }
std::string what() override { return text; }
std::pair<Value *, Pos> toValue(EvalState & state) override
{
auto v = state.allocValue();
state.eval(state.parseExprFromString(text, absPath(".")), *v);
return {v, noPos};
}
};
struct InstallableAttrPath : InstallableValue
{
2019-04-08 14:11:17 +00:00
Value * v;
std::string attrPath;
2019-04-08 14:11:17 +00:00
InstallableAttrPath(SourceExprCommand & cmd, Value * v, const std::string & attrPath)
: InstallableValue(cmd), v(v), attrPath(attrPath)
{ }
std::string what() override { return attrPath; }
std::pair<Value *, Pos> toValue(EvalState & state) override
{
auto [vRes, pos] = findAlongAttrPath(state, attrPath, *cmd.getAutoArgs(state), *v);
2019-04-08 14:11:17 +00:00
state.forceValue(*vRes);
return {vRes, pos};
}
};
void makeFlakeClosureGCRoot(Store & store,
const FlakeRef & origFlakeRef,
const flake::LockedFlake & lockedFlake)
{
#if 0
if (std::get_if<FlakeRef::IsPath>(&origFlakeRef.data)) return;
/* Get the store paths of all non-local flakes. */
StorePathSet closure;
assert(store.isValidPath(store.parseStorePath(lockedFlake.flake.sourceInfo.storePath)));
closure.insert(store.parseStorePath(lockedFlake.flake.sourceInfo.storePath));
2019-06-04 17:45:16 +00:00
std::queue<std::reference_wrapper<const flake::LockedInputs>> queue;
queue.push(lockedFlake.lockFile);
while (!queue.empty()) {
const flake::LockedInputs & flake = queue.front();
queue.pop();
2019-06-04 17:45:16 +00:00
/* Note: due to lazy fetching, these paths might not exist
yet. */
for (auto & dep : flake.inputs) {
auto path = dep.second.computeStorePath(store);
if (store.isValidPath(store.parseStorePath(path)))
closure.insert(store.parseStorePath(path));
queue.push(dep.second);
2019-06-04 17:45:16 +00:00
}
}
if (closure.empty()) return;
/* Write the closure to a file in the store. */
auto closurePath = store.addTextToStore("flake-closure",
concatStringsSep(" ", store.printStorePathSet(closure)), closure);
Path cacheDir = getCacheDir() + "/nix/flake-closures";
createDirs(cacheDir);
auto s = origFlakeRef.to_string();
assert(s[0] != '.');
s = replaceStrings(s, "%", "%25");
s = replaceStrings(s, "/", "%2f");
s = replaceStrings(s, ":", "%3a");
Path symlink = cacheDir + "/" + s;
debug("writing GC root '%s' for flake closure of '%s'", symlink, origFlakeRef);
replaceSymlink(store.printStorePath(closurePath), symlink);
store.addIndirectRoot(symlink);
#endif
}
2019-10-14 12:40:16 +00:00
std::vector<std::string> InstallableFlake::getActualAttrPaths()
{
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-10-14 12:40:16 +00:00
for (auto & s : attrPaths)
res.push_back(s);
2019-10-14 12:40:16 +00:00
return res;
}
Value * InstallableFlake::getFlakeOutputs(EvalState & state, const flake::LockedFlake & lockedFlake)
2019-10-14 12:40:16 +00:00
{
auto vFlake = state.allocValue();
callFlake(state, lockedFlake, *vFlake);
makeFlakeClosureGCRoot(*state.store, flakeRef, lockedFlake);
2019-10-14 12:40:16 +00:00
auto aOutputs = vFlake->attrs->get(state.symbols.create("outputs"));
assert(aOutputs);
2019-10-14 12:40:16 +00:00
state.forceValue(*(*aOutputs)->value);
2019-10-14 12:40:16 +00:00
return (*aOutputs)->value;
}
2019-10-21 22:21:58 +00:00
std::tuple<std::string, FlakeRef, flake::EvalCache::Derivation> InstallableFlake::toDerivation()
2019-10-14 12:40:16 +00:00
{
auto state = cmd.getEvalState();
auto lockedFlake = lockFlake(*state, flakeRef, cmd.lockFlags);
2019-10-14 12:40:16 +00:00
Value * vOutputs = nullptr;
2019-10-14 12:40:16 +00:00
auto emptyArgs = state->allocBindings(0);
2019-10-14 12:40:16 +00:00
auto & evalCache = flake::EvalCache::singleton();
auto fingerprint = lockedFlake.getFingerprint();
2019-10-14 12:40:16 +00:00
for (auto & attrPath : getActualAttrPaths()) {
auto drv = evalCache.getDerivation(fingerprint, attrPath);
if (drv) {
if (state->store->isValidPath(drv->drvPath))
2020-02-01 23:05:53 +00:00
return {attrPath, lockedFlake.flake.lockedRef, std::move(*drv)};
2019-10-14 12:40:16 +00:00
}
2019-10-14 12:40:16 +00:00
if (!vOutputs)
vOutputs = getFlakeOutputs(*state, lockedFlake);
2019-10-14 12:40:16 +00:00
try {
2020-02-07 13:08:24 +00:00
auto * v = findAlongAttrPath(*state, attrPath, *emptyArgs, *vOutputs).first;
2019-10-14 12:40:16 +00:00
state->forceValue(*v);
2019-10-14 12:40:16 +00:00
auto drvInfo = getDerivation(*state, *v, false);
if (!drvInfo)
throw Error("flake output attribute '%s' is not a derivation", attrPath);
2019-10-14 12:40:16 +00:00
auto drv = flake::EvalCache::Derivation{
state->store->parseStorePath(drvInfo->queryDrvPath()),
state->store->parseStorePath(drvInfo->queryOutPath()),
2019-10-14 12:40:16 +00:00
drvInfo->queryOutputName()
};
2019-10-14 12:40:16 +00:00
evalCache.addDerivation(fingerprint, attrPath, drv);
2020-02-01 23:05:53 +00:00
return {attrPath, lockedFlake.flake.lockedRef, std::move(drv)};
2019-10-14 12:40:16 +00:00
} catch (AttrPathNotFound & e) {
}
}
2019-10-14 12:40:16 +00:00
throw Error("flake '%s' does not provide attribute %s",
flakeRef, concatStringsSep(", ", quoteStrings(attrPaths)));
}
2019-10-21 22:21:58 +00:00
std::vector<flake::EvalCache::Derivation> InstallableFlake::toDerivations()
{
std::vector<flake::EvalCache::Derivation> res;
res.push_back(std::get<2>(toDerivation()));
return res;
2019-10-21 22:21:58 +00:00
}
std::pair<Value *, Pos> InstallableFlake::toValue(EvalState & state)
2019-10-14 12:40:16 +00:00
{
auto lockedFlake = lockFlake(state, flakeRef, cmd.lockFlags);
auto vOutputs = getFlakeOutputs(state, lockedFlake);
2019-10-14 12:40:16 +00:00
auto emptyArgs = state.allocBindings(0);
2019-10-14 12:40:16 +00:00
for (auto & attrPath : getActualAttrPaths()) {
try {
auto [v, pos] = findAlongAttrPath(state, attrPath, *emptyArgs, *vOutputs);
2019-10-14 12:40:16 +00:00
state.forceValue(*v);
return {v, pos};
2019-10-14 12:40:16 +00:00
} catch (AttrPathNotFound & e) {
}
}
2019-10-14 12:40:16 +00:00
throw Error("flake '%s' does not provide attribute %s",
flakeRef, concatStringsSep(", ", quoteStrings(attrPaths)));
}
// FIXME: extend
std::string attrRegex = R"([A-Za-z_][A-Za-z0-9-_+]*)";
static std::regex attrPathRegex(fmt(R"(%1%(\.%1%)*)", attrRegex));
2019-04-08 14:11:17 +00:00
std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
ref<Store> store, std::vector<std::string> ss)
{
std::vector<std::shared_ptr<Installable>> result;
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
if (file) evalSettings.pureEval = false;
2019-04-08 14:11:17 +00:00
auto state = getEvalState();
auto vFile = state->allocValue();
if (file)
state->evalFile(lookupFileArg(*state, *file), *vFile);
else {
auto e = state->parseExprFromString(*expr, absPath("."));
state->eval(e, *vFile);
}
2019-04-08 14:11:17 +00:00
for (auto & s : ss)
result.push_back(std::make_shared<InstallableAttrPath>(*this, vFile, s == "." ? "" : s));
2019-04-08 14:11:17 +00:00
} else {
auto follow = [&](const std::string & s) -> std::optional<StorePath> {
try {
return store->followLinksToStorePath(s);
} catch (NotInStore &) {
return {};
}
};
2019-04-08 14:11:17 +00:00
for (auto & s : ss) {
if (hasPrefix(s, "nixpkgs.")) {
bool static warned;
warnOnce(warned, "the syntax 'nixpkgs.<attr>' is deprecated; use 'nixpkgs:<attr>' instead");
2020-01-31 18:35:28 +00:00
result.push_back(std::make_shared<InstallableFlake>(*this,
FlakeRef::fromAttrs({{"type", "indirect"}, {"id", "nixpkgs"}}),
Strings{"legacyPackages." + settings.thisSystem.get() + "." + std::string(s, 8)}, Strings{}));
}
else {
auto res = maybeParseFlakeRefWithFragment(s, absPath("."));
if (res) {
auto &[flakeRef, fragment] = *res;
result.push_back(std::make_shared<InstallableFlake>(
*this, std::move(flakeRef),
fragment == "" ? getDefaultFlakeAttrPaths() : Strings{fragment},
getDefaultFlakeAttrPathPrefixes()));
} else {
2020-01-28 12:16:19 +00:00
std::optional<StorePath> storePath;
2019-09-20 14:06:49 +00:00
if (s.find('/') != std::string::npos && (storePath = follow(s)))
result.push_back(std::make_shared<InstallableStorePath>(store, store->printStorePath(*storePath)));
else
throw Error("unrecognized argument '%s'", s);
}
}
2019-04-08 14:11:17 +00:00
}
}
return result;
}
2019-04-08 14:11:17 +00:00
std::shared_ptr<Installable> SourceExprCommand::parseInstallable(
ref<Store> store, const std::string & installable)
{
2019-04-08 14:11:17 +00:00
auto installables = parseInstallables(store, {installable});
assert(installables.size() == 1);
return installables.front();
}
2018-02-09 15:42:32 +00:00
Buildables build(ref<Store> store, RealiseMode mode,
std::vector<std::shared_ptr<Installable>> installables)
{
if (mode != Build)
settings.readOnlyMode = true;
2017-09-06 14:03:22 +00:00
Buildables buildables;
std::vector<StorePathWithOutputs> pathsToBuild;
2017-09-06 14:03:22 +00:00
for (auto & i : installables) {
for (auto & b : i->toBuildables()) {
if (b.drvPath) {
StringSet outputNames;
for (auto & output : b.outputs)
outputNames.insert(output.first);
pathsToBuild.push_back({*b.drvPath, outputNames});
2017-09-27 11:14:45 +00:00
} else
for (auto & output : b.outputs)
pathsToBuild.push_back({output.second.clone()});
2017-09-06 14:03:22 +00:00
buildables.push_back(std::move(b));
}
2017-09-06 14:03:22 +00:00
}
if (mode == DryRun)
2017-09-06 14:03:22 +00:00
printMissing(store, pathsToBuild, lvlError);
else if (mode == Build)
2017-09-06 14:03:22 +00:00
store->buildPaths(pathsToBuild);
return buildables;
}
StorePathSet toStorePaths(ref<Store> store, RealiseMode mode,
std::vector<std::shared_ptr<Installable>> installables)
2017-09-06 14:03:22 +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)
outPaths.insert(output.second.clone());
return outPaths;
}
StorePath toStorePath(ref<Store> store, RealiseMode mode,
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());
return paths.begin()->clone();
}
StorePathSet toDerivations(ref<Store> store,
std::vector<std::shared_ptr<Installable>> installables, bool useDeriver)
{
StorePathSet drvPaths;
for (auto & i : installables)
for (auto & b : i->toBuildables()) {
if (!b.drvPath) {
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?
drvPaths.insert(derivers.begin()->clone());
}
} else
drvPaths.insert(b.drvPath->clone());
}
return drvPaths;
}
2017-04-25 10:06:32 +00:00
void InstallablesCommand::prepare()
{
if (_installables.empty() && useDefaultInstallables())
// 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);
}
void InstallableCommand::prepare()
{
2019-04-08 14:11:17 +00:00
installable = parseInstallable(getStore(), _installable);
}
}