#include <regex>
#include "attr-path.hh"
#include "command.hh"
#include "common-eval-args.hh"
#include "derivations.hh"
#include "eval-inline.hh"
#include "eval.hh"
#include "get-drvs.hh"
#include "shared.hh"
#include "store-api.hh"
namespace nix {
SourceExprCommand::SourceExprCommand() {
mkFlag()
.shortName('f')
.longName("file")
.label("file")
.description("evaluate FILE rather than the default")
.dest(&file);
}
Value* SourceExprCommand::getSourceExpr(EvalState& state) {
if (vSourceExpr) {
return vSourceExpr;
}
auto sToplevel = state.symbols.create("_toplevel");
vSourceExpr = state.allocValue();
if (file != "") {
state.evalFile(lookupFileArg(state, file), *vSourceExpr);
} else {
/* Construct the installation source from $NIX_PATH. */
auto searchPath = state.getSearchPath();
state.mkAttrs(*vSourceExpr, 1024);
mkBool(*state.allocAttr(*vSourceExpr, sToplevel), true);
std::unordered_set<std::string> seen;
auto addEntry = [&](const std::string& name) {
if (name == "") {
return;
}
if (!seen.insert(name).second) {
return;
}
Value* v1 = state.allocValue();
mkPrimOpApp(*v1, state.getBuiltin("findFile"),
state.getBuiltin("nixPath"));
Value* v2 = state.allocValue();
mkApp(*v2, *v1, mkString(*state.allocValue(), name));
mkApp(*state.allocAttr(*vSourceExpr, state.symbols.create(name)),
state.getBuiltin("import"), *v2);
};
for (auto& i : searchPath) { /* Hack to handle channels. */
if (i.first.empty() && pathExists(i.second + "/manifest.nix")) {
for (auto& j : readDirectory(i.second)) {
if (j.name != "manifest.nix" &&
pathExists(fmt("%s/%s/default.nix", i.second, j.name))) {
addEntry(j.name);
}
}
} else {
addEntry(i.first);
}
}
vSourceExpr->attrs->sort();
}
return vSourceExpr;
}
ref<EvalState> SourceExprCommand::getEvalState() {
if (!evalState) {
evalState = std::make_shared<EvalState>(searchPath, getStore());
}
return ref<EvalState>(evalState);
}
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;
explicit InstallableStorePath(const Path& storePath) : storePath(storePath) {}
std::string what() override { return storePath; }
Buildables toBuildables() override {
return {{isDerivation(storePath) ? storePath : "", {{"out", storePath}}}};
}
};
struct InstallableValue : Installable {
SourceExprCommand& cmd;
explicit InstallableValue(SourceExprCommand& cmd) : cmd(cmd) {}
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;
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());
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 {
std::string attrPath;
InstallableAttrPath(SourceExprCommand& cmd, const std::string& attrPath)
: InstallableValue(cmd), attrPath(attrPath) {}
std::string what() override { return attrPath; }
Value* toValue(EvalState& state) override {
auto source = cmd.getSourceExpr(state);
Bindings& autoArgs = *cmd.getAutoArgs(state);
Value* v = findAlongAttrPath(state, attrPath, autoArgs, *source);
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));
static std::vector<std::shared_ptr<Installable>> parseInstallables(
SourceExprCommand& cmd, ref<Store> store, std::vector<std::string> ss,
bool useDefaultInstallables) {
std::vector<std::shared_ptr<Installable>> result;
if (ss.empty() && useDefaultInstallables) {
if (cmd.file == "") {
cmd.file = ".";
}
ss = {""};
}
for (auto& s : ss) {
if (s.compare(0, 1, "(") == 0) {
result.push_back(std::make_shared<InstallableExpr>(cmd, s));
} else if (s.find("/") != std::string::npos) {
auto path = store->toStorePath(store->followLinksToStore(s));
if (store->isStorePath(path)) {
result.push_back(std::make_shared<InstallableStorePath>(path));
}
}
else if (s == "" || std::regex_match(s, attrPathRegex)) {
result.push_back(std::make_shared<InstallableAttrPath>(cmd, s));
} else {
throw UsageError("don't know what to do with argument '%s'", s);
}
}
return result;
}
std::shared_ptr<Installable> parseInstallable(SourceExprCommand& cmd,
ref<Store> store,
const std::string& installable,
bool useDefaultInstallables) {
auto installables = parseInstallables(cmd, store, {installable}, false);
assert(installables.size() == 1);
return installables.front();
}
Buildables build(ref<Store> store, RealiseMode mode,
std::vector<std::shared_ptr<Installable>> installables) {
if (mode != Build) {
settings.readOnlyMode = true;
}
Buildables buildables;
PathSet pathsToBuild;
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));
} else {
for (auto& output : b.outputs) {
pathsToBuild.insert(output.second);
}
}
buildables.push_back(std::move(b));
}
}
if (mode == DryRun) {
printMissing(store, pathsToBuild);
} else if (mode == Build) {
store->buildPaths(pathsToBuild);
}
return buildables;
}
PathSet toStorePaths(ref<Store> store, RealiseMode mode,
std::vector<std::shared_ptr<Installable>> installables) {
PathSet outPaths;
for (auto& b : build(store, mode, installables)) {
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) {
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;
}
void InstallablesCommand::prepare() {
installables = parseInstallables(*this, getStore(), _installables,
useDefaultInstallables());
}
void InstallableCommand::prepare() {
installable = parseInstallable(*this, getStore(), _installable, false);
}
} // namespace nix