lix/src/nix/installables.cc

342 lines
9.8 KiB
C++
Raw Normal View History

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 <regex>
namespace nix {
SourceExprCommand::SourceExprCommand()
{
mkFlag()
.shortName('f')
.longName("file")
.label("file")
2019-04-08 14:11:17 +00:00
.description("evaluate a set of attributes from FILE (deprecated)")
.dest(&file);
mkFlag()
.longName("impure")
.description("allow access to mutable paths and repositories")
.handler([&](std::vector<std::string> ss) {
evalSettings.pureEval = false;
});
}
2017-07-17 17:02:56 +00:00
ref<EvalState> SourceExprCommand::getEvalState()
{
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]);
}
struct InstallableStorePath : Installable
{
Path storePath;
InstallableStorePath(const Path & storePath) : storePath(storePath) { }
std::string what() override { return storePath; }
2017-09-06 14:03:22 +00:00
Buildables toBuildables() override
{
return {{isDerivation(storePath) ? storePath : "", {{"out", storePath}}}};
}
};
struct InstallableValue : Installable
{
SourceExprCommand & cmd;
InstallableValue(SourceExprCommand & cmd) : cmd(cmd) { }
2017-09-06 14:03:22 +00:00
Buildables toBuildables() override
{
auto state = cmd.getEvalState();
auto v = toValue(*state);
Bindings & autoArgs = *cmd.getAutoArgs(*state);
DrvInfos drvs;
getDerivations(*state, *v, "", autoArgs, drvs, false);
Buildables res;
2017-09-06 14:03:22 +00:00
PathSet drvPaths;
for (auto & drv : drvs) {
Buildable b{drv.queryDrvPath()};
drvPaths.insert(b.drvPath);
auto outputName = drv.queryOutputName();
if (outputName == "")
throw Error("derivation '%s' lacks an 'outputName' attribute", b.drvPath);
b.outputs.emplace(outputName, drv.queryOutPath());
2017-09-06 14:03:22 +00:00
res.push_back(std::move(b));
}
// Hack to recognize .all: if all drvs have the same drvPath,
// merge the buildables.
if (drvPaths.size() == 1) {
Buildable b{*drvPaths.begin()};
for (auto & b2 : res)
b.outputs.insert(b2.outputs.begin(), b2.outputs.end());
return {b};
} 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; }
Value * toValue(EvalState & state) override
{
auto v = state.allocValue();
state.eval(state.parseExprFromString(text, absPath(".")), *v);
return v;
}
};
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; }
Value * toValue(EvalState & state) override
{
2019-04-08 14:11:17 +00:00
auto vRes = findAlongAttrPath(state, attrPath, *cmd.getAutoArgs(state), *v);
state.forceValue(*vRes);
return vRes;
}
};
struct InstallableFlake : InstallableValue
{
FlakeRef flakeRef;
std::string attrPath;
InstallableFlake(SourceExprCommand & cmd, FlakeRef && flakeRef, const std::string & attrPath)
: InstallableValue(cmd), flakeRef(flakeRef), attrPath(attrPath)
{ }
std::string what() override { return flakeRef.to_string() + ":" + attrPath; }
Value * toValue(EvalState & state) override
{
auto vTemp = state.allocValue();
auto vFlake = *makeFlakeValue(state, flakeRef, true, *vTemp);
auto vProvides = (*vFlake.attrs->get(state.symbols.create("provides")))->value;
state.forceValue(*vProvides);
auto emptyArgs = state.allocBindings(0);
if (auto aPackages = *vProvides->attrs->get(state.symbols.create("packages"))) {
try {
auto * v = findAlongAttrPath(state, attrPath, *emptyArgs, *aPackages->value);
state.forceValue(*v);
return v;
} catch (AttrPathNotFound & e) {
}
}
auto * v = findAlongAttrPath(state, attrPath, *emptyArgs, *vProvides);
state.forceValue(*v);
return v;
}
};
// 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;
2019-04-08 14:11:17 +00:00
if (file) {
// FIXME: backward compatibility hack
evalSettings.pureEval = false;
2019-04-08 14:11:17 +00:00
auto state = getEvalState();
auto vFile = state->allocValue();
state->evalFile(lookupFileArg(*state, *file), *vFile);
2019-04-08 14:11:17 +00:00
if (ss.empty())
ss = {""};
2019-04-08 14:11:17 +00:00
for (auto & s : ss)
result.push_back(std::make_shared<InstallableAttrPath>(*this, vFile, s));
2019-04-08 14:11:17 +00:00
} else {
2019-04-08 14:11:17 +00:00
for (auto & s : ss) {
size_t colon;
2019-04-08 14:11:17 +00:00
if (s.compare(0, 1, "(") == 0)
result.push_back(std::make_shared<InstallableExpr>(*this, s));
else if (hasPrefix(s, "nixpkgs.")) {
bool static warned;
warnOnce(warned, "the syntax 'nixpkgs.<attr>' is deprecated; use 'nixpkgs:<attr>' instead");
result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef("nixpkgs"), std::string(s, 8)));
}
2019-04-08 14:11:17 +00:00
else if ((colon = s.rfind(':')) != std::string::npos) {
auto flakeRef = std::string(s, 0, colon);
auto attrPath = std::string(s, colon + 1);
result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef(flakeRef, true), attrPath));
}
else if (s.find('/') != std::string::npos || s == ".") {
Path storePath;
try {
storePath = store->toStorePath(store->followLinksToStore(s));
} catch (Error) { }
if (storePath != "")
result.push_back(std::make_shared<InstallableStorePath>(storePath));
else
result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef(s, true), "defaultPackage"));
2019-04-08 14:11:17 +00:00
}
else
result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef("nixpkgs"), 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;
PathSet 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.insert(
b.drvPath + "!" + concatStringsSep(",", outputNames));
2017-09-27 11:14:45 +00:00
} else
for (auto & output : b.outputs)
pathsToBuild.insert(output.second);
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;
}
PathSet toStorePaths(ref<Store> store, RealiseMode mode,
std::vector<std::shared_ptr<Installable>> installables)
2017-09-06 14:03:22 +00:00
{
PathSet outPaths;
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);
return outPaths;
}
Path 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();
}
PathSet toDerivations(ref<Store> store,
std::vector<std::shared_ptr<Installable>> installables, bool useDeriver)
{
PathSet drvPaths;
for (auto & i : installables)
for (auto & b : i->toBuildables()) {
if (b.drvPath.empty()) {
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());
}
} else
drvPaths.insert(b.drvPath);
}
return drvPaths;
}
2017-04-25 10:06:32 +00:00
void InstallablesCommand::prepare()
{
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);
}
}