2005-01-19 16:39:47 +00:00
|
|
|
#include "derivations.hh"
|
2006-11-30 17:43:04 +00:00
|
|
|
#include "store-api.hh"
|
2006-12-01 21:00:39 +00:00
|
|
|
#include "globals.hh"
|
2008-08-25 13:31:57 +00:00
|
|
|
#include "util.hh"
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
#include "worker-protocol.hh"
|
2016-06-02 16:43:36 +00:00
|
|
|
#include "fs-accessor.hh"
|
2017-03-21 13:43:03 +00:00
|
|
|
#include "istringstream_nocopy.hh"
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
namespace nix {
|
|
|
|
|
2020-03-15 06:23:17 +00:00
|
|
|
// Avoid shadow
|
|
|
|
HashType parseHashAlgo(const string & s) {
|
|
|
|
return parseHashType(s);
|
|
|
|
}
|
2006-09-04 21:06:23 +00:00
|
|
|
|
2020-06-03 16:36:06 +00:00
|
|
|
void DerivationOutput::parseHashType(FileIngestionMethod & recursive, HashType & hashType) const
|
2011-07-20 18:10:47 +00:00
|
|
|
{
|
2020-03-29 05:04:55 +00:00
|
|
|
recursive = FileIngestionMethod::Flat;
|
2011-07-20 18:10:47 +00:00
|
|
|
string algo = hashAlgo;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2011-07-20 18:10:47 +00:00
|
|
|
if (string(algo, 0, 2) == "r:") {
|
2020-03-29 05:04:55 +00:00
|
|
|
recursive = FileIngestionMethod::Recursive;
|
2011-07-20 18:10:47 +00:00
|
|
|
algo = string(algo, 2);
|
|
|
|
}
|
|
|
|
|
2020-03-15 06:23:17 +00:00
|
|
|
HashType hashType_loc = parseHashAlgo(algo);
|
|
|
|
if (hashType_loc == htUnknown)
|
2019-12-05 18:11:09 +00:00
|
|
|
throw Error("unknown hash algorithm '%s'", algo);
|
2020-03-15 06:23:17 +00:00
|
|
|
hashType = hashType_loc;
|
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2020-06-03 16:36:06 +00:00
|
|
|
void DerivationOutput::parseHashInfo(FileIngestionMethod & recursive, Hash & hash) const
|
2020-03-15 06:23:17 +00:00
|
|
|
{
|
|
|
|
HashType hashType;
|
|
|
|
parseHashType(recursive, hashType);
|
2017-07-04 12:47:59 +00:00
|
|
|
hash = Hash(this->hash, hashType);
|
2011-07-20 18:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-03 17:38:54 +00:00
|
|
|
bool derivationIsCA(DerivationType dt) {
|
|
|
|
switch (dt) {
|
|
|
|
case DerivationType::Regular: return false;
|
|
|
|
case DerivationType::CAFixed: return true;
|
|
|
|
};
|
|
|
|
// Since enums can have non-variant values, but making a `default:` would
|
|
|
|
// disable exhaustiveness warnings.
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool derivationIsFixed(DerivationType dt) {
|
|
|
|
switch (dt) {
|
|
|
|
case DerivationType::Regular: return false;
|
|
|
|
case DerivationType::CAFixed: return true;
|
|
|
|
};
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool derivationIsImpure(DerivationType dt) {
|
|
|
|
switch (dt) {
|
|
|
|
case DerivationType::Regular: return false;
|
|
|
|
case DerivationType::CAFixed: return true;
|
|
|
|
};
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
BasicDerivation::BasicDerivation(const BasicDerivation & other)
|
|
|
|
: platform(other.platform)
|
|
|
|
, builder(other.builder)
|
|
|
|
, args(other.args)
|
|
|
|
, env(other.env)
|
|
|
|
{
|
|
|
|
for (auto & i : other.outputs)
|
|
|
|
outputs.insert_or_assign(i.first,
|
|
|
|
DerivationOutput(i.second.path.clone(), std::string(i.second.hashAlgo), std::string(i.second.hash)));
|
|
|
|
for (auto & i : other.inputSrcs)
|
|
|
|
inputSrcs.insert(i.clone());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Derivation::Derivation(const Derivation & other)
|
|
|
|
: BasicDerivation(other)
|
|
|
|
{
|
|
|
|
for (auto & i : other.inputDrvs)
|
|
|
|
inputDrvs.insert_or_assign(i.first.clone(), i.second);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const StorePath & BasicDerivation::findOutput(const string & id) const
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
{
|
|
|
|
auto i = outputs.find(id);
|
|
|
|
if (i == outputs.end())
|
2019-12-05 18:11:09 +00:00
|
|
|
throw Error("derivation has no output '%s'", id);
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
return i->second.path;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BasicDerivation::isBuiltin() const
|
|
|
|
{
|
|
|
|
return string(builder, 0, 8) == "builtin:";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePath writeDerivation(ref<Store> store,
|
2020-02-17 14:53:59 +00:00
|
|
|
const Derivation & drv, std::string_view name, RepairFlag repair)
|
2003-07-04 12:18:06 +00:00
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
auto references = cloneStorePathSet(drv.inputSrcs);
|
2015-07-17 17:24:28 +00:00
|
|
|
for (auto & i : drv.inputDrvs)
|
2019-12-05 18:11:09 +00:00
|
|
|
references.insert(i.first.clone());
|
2005-01-25 21:28:25 +00:00
|
|
|
/* 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). */
|
2020-02-17 14:53:59 +00:00
|
|
|
auto suffix = std::string(name) + drvExtension;
|
|
|
|
auto contents = drv.unparse(*store, false);
|
2012-07-30 23:55:41 +00:00
|
|
|
return settings.readOnlyMode
|
2016-06-01 12:49:12 +00:00
|
|
|
? store->computeStorePathForText(suffix, contents, references)
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
: store->addTextToStore(suffix, contents, references, repair);
|
2003-07-04 12:18:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-09-14 08:54:57 +00:00
|
|
|
/* Read string `s' from stream `str'. */
|
|
|
|
static void expect(std::istream & str, const string & s)
|
|
|
|
{
|
|
|
|
char s2[s.size()];
|
|
|
|
str.read(s2, s.size());
|
|
|
|
if (string(s2, s.size()) != s)
|
2017-07-30 11:27:57 +00:00
|
|
|
throw FormatError(format("expected string '%1%'") % s);
|
2016-09-14 08:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Read a C-style string from stream `str'. */
|
|
|
|
static string parseString(std::istream & str)
|
|
|
|
{
|
|
|
|
string res;
|
|
|
|
expect(str, "\"");
|
|
|
|
int c;
|
|
|
|
while ((c = str.get()) != '"')
|
|
|
|
if (c == '\\') {
|
|
|
|
c = str.get();
|
|
|
|
if (c == 'n') res += '\n';
|
|
|
|
else if (c == 'r') res += '\r';
|
|
|
|
else if (c == 't') res += '\t';
|
|
|
|
else res += c;
|
|
|
|
}
|
|
|
|
else res += c;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-19 13:46:58 +00:00
|
|
|
static Path parsePath(std::istream & str)
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
{
|
2010-04-19 13:46:58 +00:00
|
|
|
string s = parseString(str);
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
if (s.size() == 0 || s[0] != '/')
|
2017-07-30 11:27:57 +00:00
|
|
|
throw FormatError(format("bad path '%1%' in derivation") % s);
|
2010-04-19 13:46:58 +00:00
|
|
|
return s;
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
|
2016-09-14 08:54:57 +00:00
|
|
|
static bool endOfList(std::istream & str)
|
|
|
|
{
|
|
|
|
if (str.peek() == ',') {
|
|
|
|
str.get();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (str.peek() == ']') {
|
|
|
|
str.get();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-19 13:46:58 +00:00
|
|
|
static StringSet parseStrings(std::istream & str, bool arePaths)
|
2003-07-15 16:28:54 +00:00
|
|
|
{
|
2010-04-19 13:46:58 +00:00
|
|
|
StringSet res;
|
|
|
|
while (!endOfList(str))
|
|
|
|
res.insert(arePaths ? parsePath(str) : parseString(str));
|
|
|
|
return res;
|
2003-07-15 16:28:54 +00:00
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
static Derivation parseDerivation(const Store & store, const string & s)
|
2003-07-15 21:24:05 +00:00
|
|
|
{
|
2005-01-19 11:16:11 +00:00
|
|
|
Derivation drv;
|
2017-03-06 18:03:02 +00:00
|
|
|
istringstream_nocopy str(s);
|
2010-04-19 13:46:58 +00:00
|
|
|
expect(str, "Derive([");
|
2003-11-16 17:46:31 +00:00
|
|
|
|
2010-04-19 13:46:58 +00:00
|
|
|
/* Parse the list of outputs. */
|
|
|
|
while (!endOfList(str)) {
|
2019-12-05 18:11:09 +00:00
|
|
|
expect(str, "("); std::string id = parseString(str);
|
|
|
|
expect(str, ","); auto path = store.parseStorePath(parsePath(str));
|
|
|
|
expect(str, ","); auto hashAlgo = parseString(str);
|
|
|
|
expect(str, ","); auto hash = parseString(str);
|
2010-04-19 13:46:58 +00:00
|
|
|
expect(str, ")");
|
2019-12-05 18:11:09 +00:00
|
|
|
drv.outputs.emplace(id, DerivationOutput(std::move(path), std::move(hashAlgo), std::move(hash)));
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
}
|
|
|
|
|
2010-04-19 13:46:58 +00:00
|
|
|
/* Parse the list of input derivations. */
|
|
|
|
expect(str, ",[");
|
|
|
|
while (!endOfList(str)) {
|
|
|
|
expect(str, "(");
|
|
|
|
Path drvPath = parsePath(str);
|
|
|
|
expect(str, ",[");
|
2019-12-05 18:11:09 +00:00
|
|
|
drv.inputDrvs.insert_or_assign(store.parseStorePath(drvPath), parseStrings(str, false));
|
2010-04-19 13:46:58 +00:00
|
|
|
expect(str, ")");
|
2005-01-20 14:10:19 +00:00
|
|
|
}
|
2003-07-15 16:28:54 +00:00
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
expect(str, ",["); drv.inputSrcs = store.parseStorePathSet(parseStrings(str, true));
|
2010-04-19 13:46:58 +00:00
|
|
|
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;
|
2003-08-15 12:32:37 +00:00
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2010-04-19 13:46:58 +00:00
|
|
|
expect(str, ")");
|
|
|
|
return drv;
|
|
|
|
}
|
2003-08-15 12:32:37 +00:00
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
Derivation readDerivation(const Store & store, const Path & drvPath)
|
2014-04-08 17:24:29 +00:00
|
|
|
{
|
|
|
|
try {
|
2019-12-05 18:11:09 +00:00
|
|
|
return parseDerivation(store, readFile(drvPath));
|
2014-04-08 17:24:29 +00:00
|
|
|
} catch (FormatError & e) {
|
2017-07-30 11:27:57 +00:00
|
|
|
throw Error(format("error parsing derivation '%1%': %2%") % drvPath % e.msg());
|
2014-04-08 17:24:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
Derivation Store::derivationFromPath(const StorePath & drvPath)
|
2016-06-02 16:43:36 +00:00
|
|
|
{
|
|
|
|
ensurePath(drvPath);
|
|
|
|
auto accessor = getFSAccessor();
|
|
|
|
try {
|
2019-12-05 18:11:09 +00:00
|
|
|
return parseDerivation(*this, accessor->readFile(printStorePath(drvPath)));
|
2016-06-02 16:43:36 +00:00
|
|
|
} catch (FormatError & e) {
|
2019-12-05 18:11:09 +00:00
|
|
|
throw Error("error parsing derivation '%s': %s", printStorePath(drvPath), e.msg());
|
2016-06-02 16:43:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-02-23 15:36:19 +00:00
|
|
|
static void printString(string & res, std::string_view s)
|
|
|
|
{
|
|
|
|
char buf[s.size() * 2 + 2];
|
|
|
|
char * p = buf;
|
|
|
|
*p++ = '"';
|
|
|
|
for (auto c : s)
|
|
|
|
if (c == '\"' || c == '\\') { *p++ = '\\'; *p++ = c; }
|
|
|
|
else if (c == '\n') { *p++ = '\\'; *p++ = 'n'; }
|
|
|
|
else if (c == '\r') { *p++ = '\\'; *p++ = 'r'; }
|
|
|
|
else if (c == '\t') { *p++ = '\\'; *p++ = 't'; }
|
|
|
|
else *p++ = c;
|
|
|
|
*p++ = '"';
|
|
|
|
res.append(buf, p - buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void printUnquotedString(string & res, std::string_view s)
|
2010-04-19 13:46:58 +00:00
|
|
|
{
|
2010-04-21 19:25:50 +00:00
|
|
|
res += '"';
|
2020-02-23 15:36:19 +00:00
|
|
|
res.append(s);
|
2010-04-21 19:25:50 +00:00
|
|
|
res += '"';
|
2003-07-16 11:05:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-19 13:46:58 +00:00
|
|
|
template<class ForwardIterator>
|
2010-04-21 19:25:50 +00:00
|
|
|
static void printStrings(string & res, ForwardIterator i, ForwardIterator j)
|
2003-07-15 22:28:27 +00:00
|
|
|
{
|
2010-04-21 19:25:50 +00:00
|
|
|
res += '[';
|
2010-04-19 13:46:58 +00:00
|
|
|
bool first = true;
|
|
|
|
for ( ; i != j; ++i) {
|
2010-04-21 19:25:50 +00:00
|
|
|
if (first) first = false; else res += ',';
|
|
|
|
printString(res, *i);
|
2010-04-19 13:46:58 +00:00
|
|
|
}
|
2010-04-21 19:25:50 +00:00
|
|
|
res += ']';
|
2010-04-19 13:46:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-02-23 15:36:19 +00:00
|
|
|
template<class ForwardIterator>
|
|
|
|
static void printUnquotedStrings(string & res, ForwardIterator i, ForwardIterator j)
|
|
|
|
{
|
|
|
|
res += '[';
|
|
|
|
bool first = true;
|
|
|
|
for ( ; i != j; ++i) {
|
|
|
|
if (first) first = false; else res += ',';
|
|
|
|
printUnquotedString(res, *i);
|
|
|
|
}
|
|
|
|
res += ']';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
string Derivation::unparse(const Store & store, bool maskOutputs,
|
|
|
|
std::map<std::string, StringSet> * actualInputs) const
|
2010-04-19 13:46:58 +00:00
|
|
|
{
|
2010-04-21 19:25:50 +00:00
|
|
|
string s;
|
|
|
|
s.reserve(65536);
|
|
|
|
s += "Derive([";
|
2010-04-19 13:46:58 +00:00
|
|
|
|
2020-01-21 20:14:13 +00:00
|
|
|
bool first = true;
|
|
|
|
for (auto & i : outputs) {
|
|
|
|
if (first) first = false; else s += ',';
|
2020-02-23 15:36:19 +00:00
|
|
|
s += '('; printUnquotedString(s, i.first);
|
|
|
|
s += ','; printUnquotedString(s, maskOutputs ? "" : store.printStorePath(i.second.path));
|
|
|
|
s += ','; printUnquotedString(s, i.second.hashAlgo);
|
|
|
|
s += ','; printUnquotedString(s, i.second.hash);
|
2020-01-21 20:14:13 +00:00
|
|
|
s += ')';
|
2010-04-19 13:46:58 +00:00
|
|
|
}
|
|
|
|
|
2010-04-21 19:25:50 +00:00
|
|
|
s += "],[";
|
2020-01-21 20:14:13 +00:00
|
|
|
first = true;
|
2019-12-05 18:11:09 +00:00
|
|
|
if (actualInputs) {
|
|
|
|
for (auto & i : *actualInputs) {
|
|
|
|
if (first) first = false; else s += ',';
|
2020-02-23 15:36:19 +00:00
|
|
|
s += '('; printUnquotedString(s, i.first);
|
|
|
|
s += ','; printUnquotedStrings(s, i.second.begin(), i.second.end());
|
2019-12-05 18:11:09 +00:00
|
|
|
s += ')';
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (auto & i : inputDrvs) {
|
|
|
|
if (first) first = false; else s += ',';
|
2020-02-23 15:36:19 +00:00
|
|
|
s += '('; printUnquotedString(s, store.printStorePath(i.first));
|
|
|
|
s += ','; printUnquotedStrings(s, i.second.begin(), i.second.end());
|
2019-12-05 18:11:09 +00:00
|
|
|
s += ')';
|
|
|
|
}
|
2010-04-19 13:46:58 +00:00
|
|
|
}
|
|
|
|
|
2010-04-21 19:25:50 +00:00
|
|
|
s += "],";
|
2019-12-05 18:11:09 +00:00
|
|
|
auto paths = store.printStorePathSet(inputSrcs); // FIXME: slow
|
2020-02-23 15:36:19 +00:00
|
|
|
printUnquotedStrings(s, paths.begin(), paths.end());
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2020-02-23 15:36:19 +00:00
|
|
|
s += ','; printUnquotedString(s, platform);
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
s += ','; printString(s, builder);
|
|
|
|
s += ','; printStrings(s, args.begin(), args.end());
|
2010-04-19 13:46:58 +00:00
|
|
|
|
2010-04-21 19:25:50 +00:00
|
|
|
s += ",[";
|
2010-04-19 13:46:58 +00:00
|
|
|
first = true;
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
for (auto & i : env) {
|
2010-04-21 19:25:50 +00:00
|
|
|
if (first) first = false; else s += ',';
|
2015-07-17 17:24:28 +00:00
|
|
|
s += '('; printString(s, i.first);
|
2020-01-21 20:14:13 +00:00
|
|
|
s += ','; printString(s, maskOutputs && outputs.count(i.first) ? "" : i.second);
|
2010-04-21 19:25:50 +00:00
|
|
|
s += ')';
|
2010-04-19 13:46:58 +00:00
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2010-04-21 19:25:50 +00:00
|
|
|
s += "])";
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2010-04-21 19:25:50 +00:00
|
|
|
return s;
|
2003-07-15 22:28:27 +00:00
|
|
|
}
|
2005-01-19 14:36:00 +00:00
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
// FIXME: remove
|
2005-01-19 14:36:00 +00:00
|
|
|
bool isDerivation(const string & fileName)
|
|
|
|
{
|
2008-08-25 13:31:57 +00:00
|
|
|
return hasSuffix(fileName, drvExtension);
|
2005-01-19 14:36:00 +00:00
|
|
|
}
|
2006-09-04 21:06:23 +00:00
|
|
|
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2020-03-15 06:23:17 +00:00
|
|
|
DerivationType BasicDerivation::type() const
|
2011-07-20 18:10:47 +00:00
|
|
|
{
|
2020-03-15 06:23:17 +00:00
|
|
|
if (outputs.size() == 1 &&
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
outputs.begin()->first == "out" &&
|
2020-03-15 06:23:17 +00:00
|
|
|
outputs.begin()->second.hash != "")
|
|
|
|
{
|
2020-06-03 17:38:54 +00:00
|
|
|
return DerivationType::CAFixed;
|
2020-03-15 06:23:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
auto const algo = outputs.begin()->second.hashAlgo;
|
|
|
|
if (algo != "") {
|
|
|
|
throw Error("Invalid mix of CA and regular outputs");
|
|
|
|
}
|
|
|
|
for (auto & i : outputs) {
|
|
|
|
if (i.second.hash != "") {
|
|
|
|
throw Error("Non-fixed-output derivation has fixed output");
|
|
|
|
}
|
|
|
|
if (i.second.hashAlgo != "") {
|
|
|
|
throw Error("Invalid mix of CA and regular outputs");
|
|
|
|
}
|
|
|
|
}
|
2020-06-03 17:38:54 +00:00
|
|
|
return DerivationType::Regular;
|
2011-07-20 18:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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. */
|
2019-12-05 18:11:09 +00:00
|
|
|
Hash hashDerivationModulo(Store & store, const Derivation & drv, bool maskOutputs)
|
2011-07-20 18:10:47 +00:00
|
|
|
{
|
|
|
|
/* Return a fixed hash for fixed-output derivations. */
|
2020-03-15 06:23:17 +00:00
|
|
|
switch (drv.type()) {
|
2020-06-03 17:38:54 +00:00
|
|
|
case DerivationType::CAFixed: {
|
2011-07-20 18:10:47 +00:00
|
|
|
DerivationOutputs::const_iterator i = drv.outputs.begin();
|
|
|
|
return hashString(htSHA256, "fixed:out:"
|
|
|
|
+ i->second.hashAlgo + ":"
|
|
|
|
+ i->second.hash + ":"
|
2019-12-05 18:11:09 +00:00
|
|
|
+ store.printStorePath(i->second.path));
|
2011-07-20 18:10:47 +00:00
|
|
|
}
|
2020-03-15 06:23:17 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2011-07-20 18:10:47 +00:00
|
|
|
|
|
|
|
/* For other derivations, replace the inputs paths with recursive
|
|
|
|
calls to this function.*/
|
2019-12-05 18:11:09 +00:00
|
|
|
std::map<std::string, StringSet> inputs2;
|
2015-07-17 17:24:28 +00:00
|
|
|
for (auto & i : drv.inputDrvs) {
|
2019-12-05 18:11:09 +00:00
|
|
|
auto h = drvHashes.find(i.first);
|
|
|
|
if (h == drvHashes.end()) {
|
2015-07-17 17:24:28 +00:00
|
|
|
assert(store.isValidPath(i.first));
|
2019-12-05 18:11:09 +00:00
|
|
|
h = drvHashes.insert_or_assign(i.first.clone(), hashDerivationModulo(store,
|
2020-03-30 14:04:18 +00:00
|
|
|
readDerivation(store, store.toRealPath(i.first)), false)).first;
|
2011-07-20 18:10:47 +00:00
|
|
|
}
|
2019-12-05 18:11:09 +00:00
|
|
|
inputs2.insert_or_assign(h->second.to_string(Base16, false), i.second);
|
2011-07-20 18:10:47 +00:00
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
return hashString(htSHA256, drv.unparse(store, maskOutputs, &inputs2));
|
2011-07-20 18:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
std::string StorePathWithOutputs::to_string(const Store & store) const
|
2012-11-26 14:39:10 +00:00
|
|
|
{
|
|
|
|
return outputs.empty()
|
2019-12-05 18:11:09 +00:00
|
|
|
? store.printStorePath(path)
|
|
|
|
: store.printStorePath(path) + "!" + concatStringsSep(",", outputs);
|
2012-11-26 14:39:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-11-26 16:15:09 +00:00
|
|
|
bool wantOutput(const string & output, const std::set<string> & wanted)
|
|
|
|
{
|
|
|
|
return wanted.empty() || wanted.find(output) != wanted.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet BasicDerivation::outputPaths() const
|
2015-06-10 14:17:06 +00:00
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet paths;
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
for (auto & i : outputs)
|
2019-12-05 18:11:09 +00:00
|
|
|
paths.insert(i.second.path.clone());
|
2015-06-10 14:17:06 +00:00
|
|
|
return paths;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
Source & readDerivation(Source & in, const Store & store, BasicDerivation & drv)
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
{
|
|
|
|
drv.outputs.clear();
|
2017-03-01 12:52:54 +00:00
|
|
|
auto nr = readNum<size_t>(in);
|
|
|
|
for (size_t n = 0; n < nr; n++) {
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
auto name = readString(in);
|
2019-12-05 18:11:09 +00:00
|
|
|
auto path = store.parseStorePath(readString(in));
|
|
|
|
auto hashAlgo = readString(in);
|
|
|
|
auto hash = readString(in);
|
|
|
|
drv.outputs.emplace(name, DerivationOutput(std::move(path), std::move(hashAlgo), std::move(hash)));
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
}
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
drv.inputSrcs = readStorePaths<StorePathSet>(store, in);
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
in >> drv.platform >> drv.builder;
|
|
|
|
drv.args = readStrings<Strings>(in);
|
|
|
|
|
2017-03-01 12:52:54 +00:00
|
|
|
nr = readNum<size_t>(in);
|
|
|
|
for (size_t n = 0; n < nr; n++) {
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
auto key = readString(in);
|
|
|
|
auto value = readString(in);
|
|
|
|
drv.env[key] = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
return in;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
void writeDerivation(Sink & out, const Store & store, const BasicDerivation & drv)
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
{
|
|
|
|
out << drv.outputs.size();
|
|
|
|
for (auto & i : drv.outputs)
|
2019-12-05 18:11:09 +00:00
|
|
|
out << i.first << store.printStorePath(i.second.path) << i.second.hashAlgo << i.second.hash;
|
|
|
|
writeStorePaths(store, out, drv.inputSrcs);
|
|
|
|
out << drv.platform << drv.builder << drv.args;
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
out << drv.env.size();
|
|
|
|
for (auto & i : drv.env)
|
|
|
|
out << i.first << i.second;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-17 13:12:54 +00:00
|
|
|
std::string hashPlaceholder(const std::string & outputName)
|
|
|
|
{
|
|
|
|
// FIXME: memoize?
|
2017-07-04 12:47:59 +00:00
|
|
|
return "/" + hashString(htSHA256, "nix-output:" + outputName).to_string(Base32, false);
|
2016-08-17 13:12:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
}
|