Merge remote-tracking branch 'tweag/nix-shell' into flakes

This commit is contained in:
Eelco Dolstra 2019-05-08 13:46:44 +02:00
commit 2fc8a29a9c
No known key found for this signature in database
GPG key ID: 8170B4726D7198DE
9 changed files with 367 additions and 48 deletions

View file

@ -17,5 +17,10 @@
packages.nix = hydraJobs.build.x86_64-linux; packages.nix = hydraJobs.build.x86_64-linux;
defaultPackage = packages.nix; defaultPackage = packages.nix;
devShell = import ./shell.nix {
nixpkgs = deps.nixpkgs;
};
}; };
} }

View file

@ -1,6 +1,8 @@
{ useClang ? false }: { useClang ? false
, nixpkgs ? builtins.fetchTarball https://github.com/NixOS/nixpkgs-channels/archive/nixos-19.03.tar.gz
}:
with import (builtins.fetchTarball https://github.com/NixOS/nixpkgs-channels/archive/nixos-19.03.tar.gz) {}; with import nixpkgs { system = builtins.currentSystem or "x86_64-linux"; };
with import ./release-common.nix { inherit pkgs; }; with import ./release-common.nix { inherit pkgs; };

View file

@ -1805,7 +1805,7 @@ void DerivationGoal::startBuilder()
concatStringsSep(", ", parsedDrv->getRequiredSystemFeatures()), concatStringsSep(", ", parsedDrv->getRequiredSystemFeatures()),
drvPath, drvPath,
settings.thisSystem, settings.thisSystem,
concatStringsSep(", ", settings.systemFeatures)); concatStringsSep<StringSet>(", ", settings.systemFeatures));
if (drv->isBuiltin()) if (drv->isBuiltin())
preloadNSS(); preloadNSS();

View file

@ -726,12 +726,7 @@ ValidPathInfo decodeValidPathInfo(std::istream & str, bool hashGiven)
string showPaths(const PathSet & paths) string showPaths(const PathSet & paths)
{ {
string s; return concatStringsSep(", ", quoteStrings(paths));
for (auto & i : paths) {
if (s.size() != 0) s += ", ";
s += "'" + i + "'";
}
return s;
} }

View file

@ -461,6 +461,17 @@ Path createTempDir(const Path & tmpRoot, const Path & prefix,
} }
std::pair<AutoCloseFD, Path> createTempFile(const Path & prefix)
{
Path tmpl(getEnv("TMPDIR", "/tmp") + "/" + prefix + ".XXXXXX");
// Strictly speaking, this is UB, but who cares...
AutoCloseFD fd(mkstemp((char *) tmpl.c_str()));
if (!fd)
throw SysError("creating temporary file '%s'", tmpl);
return {std::move(fd), tmpl};
}
static Lazy<Path> getHome2([]() { static Lazy<Path> getHome2([]() {
Path homeDir = getEnv("HOME"); Path homeDir = getEnv("HOME");
if (homeDir.empty()) { if (homeDir.empty()) {
@ -1167,28 +1178,6 @@ template StringSet tokenizeString(const string & s, const string & separators);
template vector<string> tokenizeString(const string & s, const string & separators); template vector<string> tokenizeString(const string & s, const string & separators);
string concatStringsSep(const string & sep, const Strings & ss)
{
string s;
for (auto & i : ss) {
if (s.size() != 0) s += sep;
s += i;
}
return s;
}
string concatStringsSep(const string & sep, const StringSet & ss)
{
string s;
for (auto & i : ss) {
if (s.size() != 0) s += sep;
s += i;
}
return s;
}
string chomp(const string & s) string chomp(const string & s)
{ {
size_t i = s.find_last_not_of(" \n\r\t"); size_t i = s.find_last_not_of(" \n\r\t");

View file

@ -118,10 +118,6 @@ void deletePath(const Path & path);
void deletePath(const Path & path, unsigned long long & bytesFreed); void deletePath(const Path & path, unsigned long long & bytesFreed);
/* Create a temporary directory. */
Path createTempDir(const Path & tmpRoot = "", const Path & prefix = "nix",
bool includePid = true, bool useGlobalCounter = true, mode_t mode = 0755);
/* Return $HOME or the user's home directory from /etc/passwd. */ /* Return $HOME or the user's home directory from /etc/passwd. */
Path getHome(); Path getHome();
@ -199,6 +195,14 @@ public:
}; };
/* Create a temporary directory. */
Path createTempDir(const Path & tmpRoot = "", const Path & prefix = "nix",
bool includePid = true, bool useGlobalCounter = true, mode_t mode = 0755);
/* Create a temporary file, returning a file handle and its path. */
std::pair<AutoCloseFD, Path> createTempFile(const Path & prefix = "nix");
class Pipe class Pipe
{ {
public: public:
@ -334,8 +338,26 @@ template<class C> C tokenizeString(const string & s, const string & separators =
/* Concatenate the given strings with a separator between the /* Concatenate the given strings with a separator between the
elements. */ elements. */
string concatStringsSep(const string & sep, const Strings & ss); template<class C>
string concatStringsSep(const string & sep, const StringSet & ss); string concatStringsSep(const string & sep, const C & ss)
{
string s;
for (auto & i : ss) {
if (s.size() != 0) s += sep;
s += i;
}
return s;
}
/* Add quotes around a collection of strings. */
template<class C> Strings quoteStrings(const C & c)
{
Strings res;
for (auto & s : c)
res.push_back("'" + s + "'");
return res;
}
/* Remove trailing whitespace from a string. */ /* Remove trailing whitespace from a string. */

View file

@ -88,6 +88,11 @@ struct SourceExprCommand : virtual Args, StoreCommand, MixEvalArgs
std::shared_ptr<Installable> parseInstallable( std::shared_ptr<Installable> parseInstallable(
ref<Store> store, const std::string & installable); ref<Store> store, const std::string & installable);
virtual Strings getDefaultFlakeAttrPaths()
{
return {"defaultPackage"};
}
private: private:
std::shared_ptr<EvalState> evalState; std::shared_ptr<EvalState> evalState;

View file

@ -142,13 +142,18 @@ struct InstallableAttrPath : InstallableValue
struct InstallableFlake : InstallableValue struct InstallableFlake : InstallableValue
{ {
FlakeRef flakeRef; FlakeRef flakeRef;
std::string attrPath; Strings attrPaths;
bool searchPackages = false;
InstallableFlake(SourceExprCommand & cmd, FlakeRef && flakeRef, const std::string & attrPath) InstallableFlake(SourceExprCommand & cmd, FlakeRef && flakeRef, Strings attrPaths)
: InstallableValue(cmd), flakeRef(flakeRef), attrPath(attrPath) : InstallableValue(cmd), flakeRef(flakeRef), attrPaths(std::move(attrPaths))
{ } { }
std::string what() override { return flakeRef.to_string() + ":" + attrPath; } InstallableFlake(SourceExprCommand & cmd, FlakeRef && flakeRef, std::string attrPath)
: InstallableValue(cmd), flakeRef(flakeRef), attrPaths{attrPath}, searchPackages(true)
{ }
std::string what() override { return flakeRef.to_string() + ":" + *attrPaths.begin(); }
Value * toValue(EvalState & state) override Value * toValue(EvalState & state) override
{ {
@ -166,18 +171,31 @@ struct InstallableFlake : InstallableValue
auto emptyArgs = state.allocBindings(0); auto emptyArgs = state.allocBindings(0);
// As a convenience, look for the attribute in
// 'provides.packages'.
if (searchPackages) {
if (auto aPackages = *vProvides->attrs->get(state.symbols.create("packages"))) { if (auto aPackages = *vProvides->attrs->get(state.symbols.create("packages"))) {
try { try {
auto * v = findAlongAttrPath(state, attrPath, *emptyArgs, *aPackages->value); auto * v = findAlongAttrPath(state, *attrPaths.begin(), *emptyArgs, *aPackages->value);
state.forceValue(*v);
return v;
} catch (AttrPathNotFound & e) {
}
}
}
// Otherwise, look for it in 'provides'.
for (auto & attrPath : attrPaths) {
try {
auto * v = findAlongAttrPath(state, attrPath, *emptyArgs, *vProvides);
state.forceValue(*v); state.forceValue(*v);
return v; return v;
} catch (AttrPathNotFound & e) { } catch (AttrPathNotFound & e) {
} }
} }
auto * v = findAlongAttrPath(state, attrPath, *emptyArgs, *vProvides); throw Error("flake '%s' does not provide attribute %s",
state.forceValue(*v); flakeRef, concatStringsSep(", ", quoteStrings(attrPaths)));
return v;
} }
}; };
@ -216,7 +234,8 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
else if (hasPrefix(s, "nixpkgs.")) { else if (hasPrefix(s, "nixpkgs.")) {
bool static warned; bool static warned;
warnOnce(warned, "the syntax 'nixpkgs.<attr>' is deprecated; use 'nixpkgs:<attr>' instead"); 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))); result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef("nixpkgs"),
Strings{"packages." + std::string(s, 8)}));
} }
else if ((colon = s.rfind(':')) != std::string::npos) { else if ((colon = s.rfind(':')) != std::string::npos) {
@ -233,7 +252,8 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
if (storePath != "") if (storePath != "")
result.push_back(std::make_shared<InstallableStorePath>(storePath)); result.push_back(std::make_shared<InstallableStorePath>(storePath));
else else
result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef(s, true), "defaultPackage")); result.push_back(std::make_shared<InstallableFlake>(*this, FlakeRef(s, true),
getDefaultFlakeAttrPaths()));
} }
else else

281
src/nix/shell.cc Normal file
View file

@ -0,0 +1,281 @@
#include "eval.hh"
#include "command.hh"
#include "common-args.hh"
#include "shared.hh"
#include "store-api.hh"
#include "derivations.hh"
#include "affinity.hh"
#include "progress-bar.hh"
using namespace nix;
struct BuildEnvironment
{
// FIXME: figure out which vars should be exported.
std::map<std::string, std::string> env;
std::map<std::string, std::string> functions;
};
BuildEnvironment readEnvironment(const Path & path)
{
BuildEnvironment res;
auto lines = tokenizeString<Strings>(readFile(path), "\n");
auto getLine =
[&]() {
if (lines.empty())
throw Error("shell environment '%s' ends unexpectedly", path);
auto line = lines.front();
lines.pop_front();
return line;
};
while (!lines.empty()) {
auto line = getLine();
auto eq = line.find('=');
if (eq != std::string::npos) {
std::string name(line, 0, eq);
std::string value(line, eq + 1);
// FIXME: parse arrays
res.env.insert({name, value});
}
else if (hasSuffix(line, " () ")) {
std::string name(line, 0, line.size() - 4);
// FIXME: validate name
auto l = getLine();
if (l != "{ ") throw Error("shell environment '%s' has unexpected line '%s'", path, l);
std::string body;
while ((l = getLine()) != "}") {
body += l;
body += '\n';
}
res.functions.insert({name, body});
}
else throw Error("shell environment '%s' has unexpected line '%s'", path, line);
}
return res;
}
/* Given an existing derivation, return the shell environment as
initialised by stdenv's setup script. We do this by building a
modified derivation with the same dependencies and nearly the same
initial environment variables, that just writes the resulting
environment to a file and exits. */
BuildEnvironment getDerivationEnvironment(ref<Store> store, Derivation drv)
{
auto builder = baseNameOf(drv.builder);
if (builder != "bash")
throw Error("'nix shell' only works on derivations that use 'bash' as their builder");
drv.args = {"-c", "set -e; if [[ -n $stdenv ]]; then source $stdenv/setup; fi; set > $out"};
/* Remove derivation checks. */
drv.env.erase("allowedReferences");
drv.env.erase("allowedRequisites");
drv.env.erase("disallowedReferences");
drv.env.erase("disallowedRequisites");
// FIXME: handle structured attrs
/* Rehash and write the derivation. FIXME: would be nice to use
'buildDerivation', but that's privileged. */
auto drvName = drv.env["name"] + "-env";
for (auto & output : drv.outputs)
drv.env.erase(output.first);
drv.env["out"] = "";
drv.env["outputs"] = "out";
drv.outputs["out"] = DerivationOutput("", "", "");
Hash h = hashDerivationModulo(*store, drv);
Path shellOutPath = store->makeOutputPath("out", h, drvName);
drv.outputs["out"].path = shellOutPath;
drv.env["out"] = shellOutPath;
Path shellDrvPath2 = writeDerivation(store, drv, drvName);
/* Build the derivation. */
store->buildPaths({shellDrvPath2});
assert(store->isValidPath(shellOutPath));
return readEnvironment(shellOutPath);
}
struct Common : InstallableCommand
{
/*
std::set<string> keepVars{
"DISPLAY",
"HOME",
"IN_NIX_SHELL",
"LOGNAME",
"NIX_BUILD_SHELL",
"PAGER",
"PATH",
"TERM",
"TZ",
"USER",
};
*/
std::set<string> ignoreVars{
"BASHOPTS",
"EUID",
"HOME", // FIXME: don't ignore in pure mode?
"NIX_BUILD_TOP",
"NIX_ENFORCE_PURITY",
"PPID",
"PWD",
"SHELLOPTS",
"SHLVL",
"TEMP",
"TEMPDIR",
"TMP",
"TMPDIR",
"TZ",
"UID",
};
void makeRcScript(const BuildEnvironment & buildEnvironment, std::ostream & out)
{
out << "export IN_NIX_SHELL=1\n";
out << "nix_saved_PATH=\"$PATH\"\n";
for (auto & i : buildEnvironment.env) {
// FIXME: shellEscape
// FIXME: figure out what to export
// FIXME: handle arrays
if (!ignoreVars.count(i.first) && !hasPrefix(i.first, "BASH_"))
out << fmt("export %s=%s\n", i.first, i.second);
}
out << "PATH=\"$PATH:$nix_saved_PATH\"\n";
for (auto & i : buildEnvironment.functions) {
out << fmt("%s () {\n%s\n}\n", i.first, i.second);
}
// FIXME: set outputs
out << "export NIX_BUILD_TOP=\"$(mktemp -d --tmpdir nix-shell.XXXXXX)\"\n";
for (auto & i : {"TMP", "TMPDIR", "TEMP", "TEMPDIR"})
out << fmt("export %s=\"$NIX_BUILD_TOP\"\n", i);
out << "eval \"$shellHook\"\n";
}
Strings getDefaultFlakeAttrPaths() override
{
return {"devShell", "defaultPackage"};
}
};
struct CmdDevShell : Common
{
std::string name() override
{
return "dev-shell";
}
std::string description() override
{
return "run a bash shell that provides the build environment of a derivation";
}
Examples examples() override
{
return {
Example{
"To get the build environment of GNU hello:",
"nix dev-shell nixpkgs:hello"
},
Example{
"To get the build environment of the default package of flake in the current directory:",
"nix dev-shell"
},
};
}
void run(ref<Store> store) override
{
auto drvs = toDerivations(store, {installable});
if (drvs.size() != 1)
throw Error("'%s' needs to evaluate to a single derivation, but it evaluated to %d derivations",
installable->what(), drvs.size());
auto & drvPath = *drvs.begin();
auto buildEnvironment = getDerivationEnvironment(store, store->derivationFromPath(drvPath));
auto [rcFileFd, rcFilePath] = createTempFile("nix-shell");
std::ostringstream ss;
makeRcScript(buildEnvironment, ss);
ss << fmt("rm -f '%s'\n", rcFilePath);
writeFull(rcFileFd.get(), ss.str());
stopProgressBar();
auto shell = getEnv("SHELL", "bash");
auto args = Strings{baseNameOf(shell), "--rcfile", rcFilePath};
restoreAffinity();
restoreSignals();
execvp(shell.c_str(), stringsToCharPtrs(args).data());
throw SysError("executing shell '%s'", shell);
}
};
struct CmdPrintDevEnv : Common
{
std::string name() override
{
return "print-dev-env";
}
std::string description() override
{
return "print shell code that can be sourced by bash to reproduce the build environment of a derivation";
}
Examples examples() override
{
return {
Example{
"To apply the build environment of GNU hello to the current shell:",
". <(nix print-dev-env nixpkgs:hello)"
},
};
}
void run(ref<Store> store) override
{
auto drvs = toDerivations(store, {installable});
if (drvs.size() != 1)
throw Error("'%s' needs to evaluate to a single derivation, but it evaluated to %d derivations",
installable->what(), drvs.size());
auto & drvPath = *drvs.begin();
auto buildEnvironment = getDerivationEnvironment(store, store->derivationFromPath(drvPath));
stopProgressBar();
makeRcScript(buildEnvironment, std::cout);
}
};
static RegisterCommand r1(make_ref<CmdPrintDevEnv>());
static RegisterCommand r2(make_ref<CmdDevShell>());