Restructure installables handling in the "nix" command

This commit is contained in:
Eelco Dolstra 2017-04-25 11:20:37 +02:00
parent 1bb87c0487
commit bcecc99007
No known key found for this signature in database
GPG key ID: 8170B4726D7198DE
9 changed files with 265 additions and 132 deletions

View file

@ -220,6 +220,14 @@ static inline void mkApp(Value & v, Value & left, Value & right)
} }
static inline void mkPrimOpApp(Value & v, Value & left, Value & right)
{
v.type = tPrimOpApp;
v.app.left = &left;
v.app.right = &right;
}
static inline void mkStringNoCopy(Value & v, const char * s) static inline void mkStringNoCopy(Value & v, const char * s)
{ {
v.type = tString; v.type = tString;

View file

@ -6,7 +6,7 @@
using namespace nix; using namespace nix;
struct CmdBuild : StoreCommand, MixDryRun, MixInstallables struct CmdBuild : MixDryRun, MixInstallables
{ {
CmdBuild() CmdBuild()
{ {
@ -24,22 +24,9 @@ struct CmdBuild : StoreCommand, MixDryRun, MixInstallables
void run(ref<Store> store) override void run(ref<Store> store) override
{ {
auto elems = evalInstallables(store); auto paths = buildInstallables(store, dryRun);
PathSet pathsToBuild; printInfo("build result: %s", showPaths(paths));
for (auto & elem : elems) {
if (elem.isDrv)
pathsToBuild.insert(elem.drvPath);
else
pathsToBuild.insert(elem.outPaths.begin(), elem.outPaths.end());
}
printMissing(store, pathsToBuild);
if (dryRun) return;
store->buildPaths(pathsToBuild);
} }
}; };

View file

@ -79,6 +79,13 @@ StoreCommand::StoreCommand()
mkFlag(0, "store", "store-uri", "URI of the Nix store to use", &storeUri); mkFlag(0, "store", "store-uri", "URI of the Nix store to use", &storeUri);
} }
ref<Store> StoreCommand::getStore()
{
if (!_store)
_store = createStore();
return ref<Store>(_store);
}
ref<Store> StoreCommand::createStore() ref<Store> StoreCommand::createStore()
{ {
return openStore(storeUri); return openStore(storeUri);

View file

@ -33,8 +33,12 @@ struct StoreCommand : virtual Command
std::string storeUri; std::string storeUri;
StoreCommand(); StoreCommand();
void run() override; void run() override;
ref<Store> getStore();
virtual ref<Store> createStore(); virtual ref<Store> createStore();
virtual void run(ref<Store>) = 0; virtual void run(ref<Store>) = 0;
private:
std::shared_ptr<Store> _store;
}; };
/* A command that operates on zero or more store paths. */ /* A command that operates on zero or more store paths. */

View file

@ -6,16 +6,21 @@
#include "get-drvs.hh" #include "get-drvs.hh"
#include "installables.hh" #include "installables.hh"
#include "store-api.hh" #include "store-api.hh"
#include "shared.hh"
#include <regex>
namespace nix { namespace nix {
Value * MixInstallables::buildSourceExpr(EvalState & state) Value * MixInstallables::getSourceExpr(EvalState & state)
{ {
Value * vRoot = state.allocValue(); if (vSourceExpr) return vSourceExpr;
vSourceExpr = state.allocValue();
if (file != "") { if (file != "") {
Expr * e = state.parseExprFromFile(resolveExprPath(lookupFileArg(state, file))); Expr * e = state.parseExprFromFile(resolveExprPath(lookupFileArg(state, file)));
state.eval(e, *vRoot); state.eval(e, *vSourceExpr);
} }
else { else {
@ -24,7 +29,7 @@ Value * MixInstallables::buildSourceExpr(EvalState & state)
auto searchPath = state.getSearchPath(); auto searchPath = state.getSearchPath();
state.mkAttrs(*vRoot, searchPath.size()); state.mkAttrs(*vSourceExpr, searchPath.size());
std::unordered_set<std::string> seen; std::unordered_set<std::string> seen;
@ -32,76 +37,208 @@ Value * MixInstallables::buildSourceExpr(EvalState & state)
if (i.first == "") continue; if (i.first == "") continue;
if (seen.count(i.first)) continue; if (seen.count(i.first)) continue;
seen.insert(i.first); seen.insert(i.first);
if (!pathExists(i.second)) continue; #if 0
mkApp(*state.allocAttr(*vRoot, state.symbols.create(i.first)), auto res = state.resolveSearchPathElem(i);
if (!res.first) continue;
if (!pathExists(res.second)) continue;
mkApp(*state.allocAttr(*vSourceExpr, state.symbols.create(i.first)),
state.getBuiltin("import"), state.getBuiltin("import"),
mkString(*state.allocValue(), i.second)); mkString(*state.allocValue(), res.second));
#endif
Value * v1 = state.allocValue();
mkPrimOpApp(*v1, state.getBuiltin("findFile"), state.getBuiltin("nixPath"));
Value * v2 = state.allocValue();
mkApp(*v2, *v1, mkString(*state.allocValue(), i.first));
mkApp(*state.allocAttr(*vSourceExpr, state.symbols.create(i.first)),
state.getBuiltin("import"), *v2);
} }
vRoot->attrs->sort(); vSourceExpr->attrs->sort();
} }
return vRoot; return vSourceExpr;
} }
UserEnvElems MixInstallables::evalInstallables(ref<Store> store) struct InstallableStoreDrv : Installable
{ {
UserEnvElems res; Path storePath;
InstallableStoreDrv(const Path & storePath) : storePath(storePath) { }
std::string what() override { return storePath; }
PathSet toBuildable() override
{
return {storePath};
}
};
struct InstallableStorePath : Installable
{
Path storePath;
InstallableStorePath(const Path & storePath) : storePath(storePath) { }
std::string what() override { return storePath; }
PathSet toBuildable() override
{
return {storePath};
}
};
struct InstallableExpr : Installable
{
MixInstallables & installables;
std::string text;
InstallableExpr(MixInstallables & installables, const std::string & text)
: installables(installables), text(text) { }
std::string what() override { return text; }
PathSet toBuildable() override
{
auto state = installables.getEvalState();
auto v = toValue(*state);
// FIXME
std::map<string, string> autoArgs_;
Bindings & autoArgs(*evalAutoArgs(*state, autoArgs_));
DrvInfos drvs;
getDerivations(*state, *v, "", autoArgs, drvs, false);
PathSet res;
for (auto & i : drvs)
res.insert(i.queryDrvPath());
return res;
}
Value * toValue(EvalState & state) override
{
auto v = state.allocValue();
state.eval(state.parseExprFromString(text, absPath(".")), *v);
return v;
}
};
struct InstallableAttrPath : Installable
{
MixInstallables & installables;
std::string attrPath;
InstallableAttrPath(MixInstallables & installables, const std::string & attrPath)
: installables(installables), attrPath(attrPath)
{ }
std::string what() override { return attrPath; }
PathSet toBuildable() override
{
auto state = installables.getEvalState();
auto v = toValue(*state);
// FIXME
std::map<string, string> autoArgs_;
Bindings & autoArgs(*evalAutoArgs(*state, autoArgs_));
DrvInfos drvs;
getDerivations(*state, *v, "", autoArgs, drvs, false);
PathSet res;
for (auto & i : drvs)
res.insert(i.queryDrvPath());
return res;
}
Value * toValue(EvalState & state) override
{
auto source = installables.getSourceExpr(state);
// FIXME
std::map<string, string> autoArgs_;
Bindings & autoArgs(*evalAutoArgs(state, autoArgs_));
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));
std::vector<std::shared_ptr<Installable>> MixInstallables::parseInstallables(ref<Store> store, Strings installables)
{
std::vector<std::shared_ptr<Installable>> result;
for (auto & installable : installables) { for (auto & installable : installables) {
if (std::string(installable, 0, 1) == "/") { if (std::string(installable, 0, 1) == "/") {
if (store->isStorePath(installable)) { if (store->isStorePath(installable)) {
if (isDerivation(installable))
if (isDerivation(installable)) { result.push_back(std::make_shared<InstallableStoreDrv>(installable));
UserEnvElem elem; else
// FIXME: handle empty case, drop version result.push_back(std::make_shared<InstallableStorePath>(installable));
elem.attrPath = {storePathToName(installable)};
elem.isDrv = true;
elem.drvPath = installable;
res.push_back(elem);
} }
else { else {
UserEnvElem elem; result.push_back(std::make_shared<InstallableStorePath>(
// FIXME: handle empty case, drop version store->toStorePath(store->followLinksToStore(installable))));
elem.attrPath = {storePathToName(installable)};
elem.isDrv = false;
elem.outPaths = {installable};
res.push_back(elem);
} }
} }
else if (installable.compare(0, 1, "(") == 0)
result.push_back(std::make_shared<InstallableExpr>(*this, installable));
else if (std::regex_match(installable, attrPathRegex))
result.push_back(std::make_shared<InstallableAttrPath>(*this, installable));
else else
throw UsageError(format("don't know what to do with %1%") % installable); throw UsageError("don't know what to do with argument %s", installable);
} }
else { return result;
}
EvalState state({}, store); PathSet MixInstallables::buildInstallables(ref<Store> store, bool dryRun)
{
PathSet buildables;
auto vRoot = buildSourceExpr(state); for (auto & i : installables) {
auto b = i->toBuildable();
std::map<string, string> autoArgs_; buildables.insert(b.begin(), b.end());
Bindings & autoArgs(*evalAutoArgs(state, autoArgs_));
Value & v(*findAlongAttrPath(state, installable, autoArgs, *vRoot));
state.forceValue(v);
DrvInfos drvs;
getDerivations(state, v, "", autoArgs, drvs, false);
for (auto & i : drvs) {
UserEnvElem elem;
elem.isDrv = true;
elem.drvPath = i.queryDrvPath();
res.push_back(elem);
}
}
} }
return res; printMissing(store, buildables);
if (!dryRun)
store->buildPaths(buildables);
return buildables;
}
ref<EvalState> MixInstallables::getEvalState()
{
if (!evalState)
evalState = std::make_shared<EvalState>(Strings{}, getStore());
return ref<EvalState>(evalState);
}
void MixInstallables::prepare()
{
installables = parseInstallables(getStore(), _installables);
} }
} }

View file

@ -1,48 +1,61 @@
#pragma once #pragma once
#include "args.hh" #include "args.hh"
#include "command.hh"
namespace nix { namespace nix {
struct UserEnvElem
{
Strings attrPath;
// FIXME: should use boost::variant or so.
bool isDrv;
// Derivation case:
Path drvPath;
StringSet outputNames;
// Non-derivation case:
PathSet outPaths;
};
typedef std::vector<UserEnvElem> UserEnvElems;
struct Value; struct Value;
class EvalState; class EvalState;
class Expr;
struct MixInstallables : virtual Args struct Installable
{ {
Strings installables; virtual std::string what() = 0;
virtual PathSet toBuildable()
{
throw Error("argument %s cannot be built", what());
}
virtual Value * toValue(EvalState & state)
{
throw Error("argument %s cannot be evaluated", what());
}
};
struct MixInstallables : virtual Args, StoreCommand
{
std::vector<std::shared_ptr<Installable>> installables;
Path file; Path file;
MixInstallables() MixInstallables()
{ {
mkFlag('f', "file", "file", "evaluate FILE rather than the default", &file); mkFlag('f', "file", "file", "evaluate FILE rather than the default", &file);
expectArgs("installables", &installables); expectArgs("installables", &_installables);
} }
UserEnvElems evalInstallables(ref<Store> store);
/* Return a value representing the Nix expression from which we /* Return a value representing the Nix expression from which we
are installing. This is either the file specified by --file, are installing. This is either the file specified by --file,
or an attribute set constructed from $NIX_PATH, e.g. { nixpkgs or an attribute set constructed from $NIX_PATH, e.g. { nixpkgs
= import ...; bla = import ...; }. */ = import ...; bla = import ...; }. */
Value * buildSourceExpr(EvalState & state); Value * getSourceExpr(EvalState & state);
std::vector<std::shared_ptr<Installable>> parseInstallables(ref<Store> store, Strings installables);
PathSet buildInstallables(ref<Store> store, bool dryRun);
ref<EvalState> getEvalState();
void prepare() override;
private:
Strings _installables;
std::shared_ptr<EvalState> evalState;
Value * vSourceExpr = 0;
}; };
} }

View file

@ -6,7 +6,7 @@
using namespace nix; using namespace nix;
struct CmdLog : StoreCommand, MixInstallables struct CmdLog : MixInstallables
{ {
CmdLog() CmdLog()
{ {
@ -24,22 +24,12 @@ struct CmdLog : StoreCommand, MixInstallables
void run(ref<Store> store) override void run(ref<Store> store) override
{ {
auto elems = evalInstallables(store);
PathSet paths;
for (auto & elem : elems) {
if (elem.isDrv)
paths.insert(elem.drvPath);
else
paths.insert(elem.outPaths.begin(), elem.outPaths.end());
}
auto subs = getDefaultSubstituters(); auto subs = getDefaultSubstituters();
subs.push_front(store); subs.push_front(store);
for (auto & path : paths) { for (auto & inst : installables) {
for (auto & path : inst->toBuildable()) {
bool found = false; bool found = false;
for (auto & sub : subs) { for (auto & sub : subs) {
auto log = sub->getBuildLog(path); auto log = sub->getBuildLog(path);
@ -52,6 +42,7 @@ struct CmdLog : StoreCommand, MixInstallables
throw Error("build log of path %s is not available", path); throw Error("build log of path %s is not available", path);
} }
} }
}
}; };
static RegisterCommand r1(make_ref<CmdLog>()); static RegisterCommand r1(make_ref<CmdLog>());

View file

@ -99,7 +99,6 @@ struct CmdPathInfo : StorePathsCommand, MixJSON
} }
} }
} }
}; };

View file

@ -13,7 +13,7 @@
using namespace nix; using namespace nix;
struct CmdRun : StoreCommand, MixInstallables struct CmdRun : MixInstallables
{ {
CmdRun() CmdRun()
{ {
@ -31,20 +31,7 @@ struct CmdRun : StoreCommand, MixInstallables
void run(ref<Store> store) override void run(ref<Store> store) override
{ {
auto elems = evalInstallables(store); auto paths = buildInstallables(store, false);
PathSet pathsToBuild;
for (auto & elem : elems) {
if (elem.isDrv)
pathsToBuild.insert(elem.drvPath);
else
pathsToBuild.insert(elem.outPaths.begin(), elem.outPaths.end());
}
printMissing(store, pathsToBuild);
store->buildPaths(pathsToBuild);
auto store2 = store.dynamic_pointer_cast<LocalStore>(); auto store2 = store.dynamic_pointer_cast<LocalStore>();
@ -104,7 +91,7 @@ struct CmdRun : StoreCommand, MixInstallables
} }
PathSet outPaths; PathSet outPaths;
for (auto & path : pathsToBuild) for (auto & path : paths)
if (isDerivation(path)) { if (isDerivation(path)) {
Derivation drv = store->derivationFromPath(path); Derivation drv = store->derivationFromPath(path);
for (auto & output : drv.outputs) for (auto & output : drv.outputs)