forked from lix-project/lix
22d6e31fc6
For example, you can now say:
configureFlags = "--prefix=${placeholder "out"} --includedir=${placeholder "dev"}";
The strings returned by the ‘placeholder’ builtin are replaced at
build time by the actual store paths corresponding to the specified
outputs.
Previously, you had to work around the inability to self-reference by doing stuff like:
preConfigure = ''
configureFlags+=" --prefix $out --includedir=$dev"
'';
or rely on ad-hoc variable interpolation semantics in Autoconf or Make
(e.g. --prefix=\$(out)), which doesn't always work.
401 lines
11 KiB
C++
401 lines
11 KiB
C++
#include "derivations.hh"
|
||
#include "store-api.hh"
|
||
#include "globals.hh"
|
||
#include "util.hh"
|
||
#include "worker-protocol.hh"
|
||
#include "fs-accessor.hh"
|
||
|
||
|
||
namespace nix {
|
||
|
||
|
||
void DerivationOutput::parseHashInfo(bool & recursive, Hash & hash) const
|
||
{
|
||
recursive = false;
|
||
string algo = hashAlgo;
|
||
|
||
if (string(algo, 0, 2) == "r:") {
|
||
recursive = true;
|
||
algo = string(algo, 2);
|
||
}
|
||
|
||
HashType hashType = parseHashType(algo);
|
||
if (hashType == htUnknown)
|
||
throw Error(format("unknown hash algorithm ‘%1%’") % algo);
|
||
|
||
hash = parseHash(hashType, this->hash);
|
||
}
|
||
|
||
|
||
Path BasicDerivation::findOutput(const string & id) const
|
||
{
|
||
auto i = outputs.find(id);
|
||
if (i == outputs.end())
|
||
throw Error(format("derivation has no output ‘%1%’") % id);
|
||
return i->second.path;
|
||
}
|
||
|
||
|
||
bool BasicDerivation::willBuildLocally() const
|
||
{
|
||
return get(env, "preferLocalBuild") == "1" && canBuildLocally();
|
||
}
|
||
|
||
|
||
bool BasicDerivation::substitutesAllowed() const
|
||
{
|
||
return get(env, "allowSubstitutes", "1") == "1";
|
||
}
|
||
|
||
|
||
bool BasicDerivation::isBuiltin() const
|
||
{
|
||
return string(builder, 0, 8) == "builtin:";
|
||
}
|
||
|
||
|
||
bool BasicDerivation::canBuildLocally() const
|
||
{
|
||
return platform == settings.thisSystem
|
||
|| isBuiltin()
|
||
#if __linux__
|
||
|| (platform == "i686-linux" && settings.thisSystem == "x86_64-linux")
|
||
|| (platform == "armv6l-linux" && settings.thisSystem == "armv7l-linux")
|
||
#elif __FreeBSD__
|
||
|| (platform == "i686-linux" && settings.thisSystem == "x86_64-freebsd")
|
||
|| (platform == "i686-linux" && settings.thisSystem == "i686-freebsd")
|
||
#endif
|
||
;
|
||
}
|
||
|
||
|
||
Path writeDerivation(ref<Store> store,
|
||
const Derivation & drv, const string & name, bool repair)
|
||
{
|
||
PathSet references;
|
||
references.insert(drv.inputSrcs.begin(), drv.inputSrcs.end());
|
||
for (auto & i : drv.inputDrvs)
|
||
references.insert(i.first);
|
||
/* Note that the outputs of a derivation are *not* references
|
||
(that can be missing (of course) and should not necessarily be
|
||
held during a garbage collection). */
|
||
string suffix = name + drvExtension;
|
||
string contents = drv.unparse();
|
||
return settings.readOnlyMode
|
||
? store->computeStorePathForText(suffix, contents, references)
|
||
: store->addTextToStore(suffix, contents, references, repair);
|
||
}
|
||
|
||
|
||
static Path parsePath(std::istream & str)
|
||
{
|
||
string s = parseString(str);
|
||
if (s.size() == 0 || s[0] != '/')
|
||
throw FormatError(format("bad path ‘%1%’ in derivation") % s);
|
||
return s;
|
||
}
|
||
|
||
|
||
static StringSet parseStrings(std::istream & str, bool arePaths)
|
||
{
|
||
StringSet res;
|
||
while (!endOfList(str))
|
||
res.insert(arePaths ? parsePath(str) : parseString(str));
|
||
return res;
|
||
}
|
||
|
||
|
||
static Derivation parseDerivation(const string & s)
|
||
{
|
||
Derivation drv;
|
||
std::istringstream str(s);
|
||
expect(str, "Derive([");
|
||
|
||
/* Parse the list of outputs. */
|
||
while (!endOfList(str)) {
|
||
DerivationOutput out;
|
||
expect(str, "("); string id = parseString(str);
|
||
expect(str, ","); out.path = parsePath(str);
|
||
expect(str, ","); out.hashAlgo = parseString(str);
|
||
expect(str, ","); out.hash = parseString(str);
|
||
expect(str, ")");
|
||
drv.outputs[id] = out;
|
||
}
|
||
|
||
/* Parse the list of input derivations. */
|
||
expect(str, ",[");
|
||
while (!endOfList(str)) {
|
||
expect(str, "(");
|
||
Path drvPath = parsePath(str);
|
||
expect(str, ",[");
|
||
drv.inputDrvs[drvPath] = parseStrings(str, false);
|
||
expect(str, ")");
|
||
}
|
||
|
||
expect(str, ",["); drv.inputSrcs = parseStrings(str, true);
|
||
expect(str, ","); drv.platform = parseString(str);
|
||
expect(str, ","); drv.builder = parseString(str);
|
||
|
||
/* Parse the builder arguments. */
|
||
expect(str, ",[");
|
||
while (!endOfList(str))
|
||
drv.args.push_back(parseString(str));
|
||
|
||
/* Parse the environment variables. */
|
||
expect(str, ",[");
|
||
while (!endOfList(str)) {
|
||
expect(str, "("); string name = parseString(str);
|
||
expect(str, ","); string value = parseString(str);
|
||
expect(str, ")");
|
||
drv.env[name] = value;
|
||
}
|
||
|
||
expect(str, ")");
|
||
return drv;
|
||
}
|
||
|
||
|
||
Derivation readDerivation(const Path & drvPath)
|
||
{
|
||
try {
|
||
return parseDerivation(readFile(drvPath));
|
||
} catch (FormatError & e) {
|
||
throw Error(format("error parsing derivation ‘%1%’: %2%") % drvPath % e.msg());
|
||
}
|
||
}
|
||
|
||
|
||
Derivation Store::derivationFromPath(const Path & drvPath)
|
||
{
|
||
assertStorePath(drvPath);
|
||
ensurePath(drvPath);
|
||
auto accessor = getFSAccessor();
|
||
try {
|
||
return parseDerivation(accessor->readFile(drvPath));
|
||
} catch (FormatError & e) {
|
||
throw Error(format("error parsing derivation ‘%1%’: %2%") % drvPath % e.msg());
|
||
}
|
||
}
|
||
|
||
|
||
static void printString(string & res, const string & s)
|
||
{
|
||
res += '"';
|
||
for (const char * i = s.c_str(); *i; i++)
|
||
if (*i == '\"' || *i == '\\') { res += "\\"; res += *i; }
|
||
else if (*i == '\n') res += "\\n";
|
||
else if (*i == '\r') res += "\\r";
|
||
else if (*i == '\t') res += "\\t";
|
||
else res += *i;
|
||
res += '"';
|
||
}
|
||
|
||
|
||
template<class ForwardIterator>
|
||
static void printStrings(string & res, ForwardIterator i, ForwardIterator j)
|
||
{
|
||
res += '[';
|
||
bool first = true;
|
||
for ( ; i != j; ++i) {
|
||
if (first) first = false; else res += ',';
|
||
printString(res, *i);
|
||
}
|
||
res += ']';
|
||
}
|
||
|
||
|
||
string Derivation::unparse() const
|
||
{
|
||
string s;
|
||
s.reserve(65536);
|
||
s += "Derive([";
|
||
|
||
bool first = true;
|
||
for (auto & i : outputs) {
|
||
if (first) first = false; else s += ',';
|
||
s += '('; printString(s, i.first);
|
||
s += ','; printString(s, i.second.path);
|
||
s += ','; printString(s, i.second.hashAlgo);
|
||
s += ','; printString(s, i.second.hash);
|
||
s += ')';
|
||
}
|
||
|
||
s += "],[";
|
||
first = true;
|
||
for (auto & i : inputDrvs) {
|
||
if (first) first = false; else s += ',';
|
||
s += '('; printString(s, i.first);
|
||
s += ','; printStrings(s, i.second.begin(), i.second.end());
|
||
s += ')';
|
||
}
|
||
|
||
s += "],";
|
||
printStrings(s, inputSrcs.begin(), inputSrcs.end());
|
||
|
||
s += ','; printString(s, platform);
|
||
s += ','; printString(s, builder);
|
||
s += ','; printStrings(s, args.begin(), args.end());
|
||
|
||
s += ",[";
|
||
first = true;
|
||
for (auto & i : env) {
|
||
if (first) first = false; else s += ',';
|
||
s += '('; printString(s, i.first);
|
||
s += ','; printString(s, i.second);
|
||
s += ')';
|
||
}
|
||
|
||
s += "])";
|
||
|
||
return s;
|
||
}
|
||
|
||
|
||
bool isDerivation(const string & fileName)
|
||
{
|
||
return hasSuffix(fileName, drvExtension);
|
||
}
|
||
|
||
|
||
bool BasicDerivation::isFixedOutput() const
|
||
{
|
||
return outputs.size() == 1 &&
|
||
outputs.begin()->first == "out" &&
|
||
outputs.begin()->second.hash != "";
|
||
}
|
||
|
||
|
||
DrvHashes drvHashes;
|
||
|
||
|
||
/* Returns the hash of a derivation modulo fixed-output
|
||
subderivations. A fixed-output derivation is a derivation with one
|
||
output (`out') for which an expected hash and hash algorithm are
|
||
specified (using the `outputHash' and `outputHashAlgo'
|
||
attributes). We don't want changes to such derivations to
|
||
propagate upwards through the dependency graph, changing output
|
||
paths everywhere.
|
||
|
||
For instance, if we change the url in a call to the `fetchurl'
|
||
function, we do not want to rebuild everything depending on it
|
||
(after all, (the hash of) the file being downloaded is unchanged).
|
||
So the *output paths* should not change. On the other hand, the
|
||
*derivation paths* should change to reflect the new dependency
|
||
graph.
|
||
|
||
That's what this function does: it returns a hash which is just the
|
||
hash of the derivation ATerm, except that any input derivation
|
||
paths have been replaced by the result of a recursive call to this
|
||
function, and that for fixed-output derivations we return a hash of
|
||
its output path. */
|
||
Hash hashDerivationModulo(Store & store, Derivation drv)
|
||
{
|
||
/* Return a fixed hash for fixed-output derivations. */
|
||
if (drv.isFixedOutput()) {
|
||
DerivationOutputs::const_iterator i = drv.outputs.begin();
|
||
return hashString(htSHA256, "fixed:out:"
|
||
+ i->second.hashAlgo + ":"
|
||
+ i->second.hash + ":"
|
||
+ i->second.path);
|
||
}
|
||
|
||
/* For other derivations, replace the inputs paths with recursive
|
||
calls to this function.*/
|
||
DerivationInputs inputs2;
|
||
for (auto & i : drv.inputDrvs) {
|
||
Hash h = drvHashes[i.first];
|
||
if (!h) {
|
||
assert(store.isValidPath(i.first));
|
||
Derivation drv2 = readDerivation(i.first);
|
||
h = hashDerivationModulo(store, drv2);
|
||
drvHashes[i.first] = h;
|
||
}
|
||
inputs2[printHash(h)] = i.second;
|
||
}
|
||
drv.inputDrvs = inputs2;
|
||
|
||
return hashString(htSHA256, drv.unparse());
|
||
}
|
||
|
||
|
||
DrvPathWithOutputs parseDrvPathWithOutputs(const string & s)
|
||
{
|
||
size_t n = s.find("!");
|
||
return n == s.npos
|
||
? DrvPathWithOutputs(s, std::set<string>())
|
||
: DrvPathWithOutputs(string(s, 0, n), tokenizeString<std::set<string> >(string(s, n + 1), ","));
|
||
}
|
||
|
||
|
||
Path makeDrvPathWithOutputs(const Path & drvPath, const std::set<string> & outputs)
|
||
{
|
||
return outputs.empty()
|
||
? drvPath
|
||
: drvPath + "!" + concatStringsSep(",", outputs);
|
||
}
|
||
|
||
|
||
bool wantOutput(const string & output, const std::set<string> & wanted)
|
||
{
|
||
return wanted.empty() || wanted.find(output) != wanted.end();
|
||
}
|
||
|
||
|
||
PathSet BasicDerivation::outputPaths() const
|
||
{
|
||
PathSet paths;
|
||
for (auto & i : outputs)
|
||
paths.insert(i.second.path);
|
||
return paths;
|
||
}
|
||
|
||
|
||
Source & readDerivation(Source & in, Store & store, BasicDerivation & drv)
|
||
{
|
||
drv.outputs.clear();
|
||
auto nr = readInt(in);
|
||
for (unsigned int n = 0; n < nr; n++) {
|
||
auto name = readString(in);
|
||
DerivationOutput o;
|
||
in >> o.path >> o.hashAlgo >> o.hash;
|
||
store.assertStorePath(o.path);
|
||
drv.outputs[name] = o;
|
||
}
|
||
|
||
drv.inputSrcs = readStorePaths<PathSet>(store, in);
|
||
in >> drv.platform >> drv.builder;
|
||
drv.args = readStrings<Strings>(in);
|
||
|
||
nr = readInt(in);
|
||
for (unsigned int n = 0; n < nr; n++) {
|
||
auto key = readString(in);
|
||
auto value = readString(in);
|
||
drv.env[key] = value;
|
||
}
|
||
|
||
return in;
|
||
}
|
||
|
||
|
||
Sink & operator << (Sink & out, const BasicDerivation & drv)
|
||
{
|
||
out << drv.outputs.size();
|
||
for (auto & i : drv.outputs)
|
||
out << i.first << i.second.path << i.second.hashAlgo << i.second.hash;
|
||
out << drv.inputSrcs << drv.platform << drv.builder << drv.args;
|
||
out << drv.env.size();
|
||
for (auto & i : drv.env)
|
||
out << i.first << i.second;
|
||
return out;
|
||
}
|
||
|
||
|
||
std::string hashPlaceholder(const std::string & outputName)
|
||
{
|
||
// FIXME: memoize?
|
||
return "/" + printHash32(hashString(htSHA256, "nix-output:" + outputName));
|
||
}
|
||
|
||
|
||
}
|