aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/libexpr/primops.cc13
-rw-r--r--src/libstore/build.cc21
-rw-r--r--src/libstore/derivations.cc99
-rw-r--r--src/libstore/derivations.hh23
-rw-r--r--src/libstore/local-store.cc10
-rw-r--r--src/libstore/nar-info.cc2
-rw-r--r--src/libstore/path.hh14
-rw-r--r--src/libstore/store-api.cc43
-rw-r--r--src/libstore/store-api.hh8
-rw-r--r--src/libutil/hash.hh6
-rw-r--r--src/libutil/rust-ffi.hh32
-rwxr-xr-xsrc/libutil/tests/libutil-testsbin0 -> 14929616 bytes
-rw-r--r--src/nix/dev-shell.cc4
-rw-r--r--src/nix/show-derivation.cc6
14 files changed, 187 insertions, 94 deletions
diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
index 8fbcef8c8..b6e889e15 100644
--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -723,12 +723,9 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
auto outPath = state.store->makeFixedOutputPath(ingestionMethod, h, drvName);
if (!jsonObject) drv.env["out"] = state.store->printStorePath(outPath);
- drv.outputs.insert_or_assign("out", DerivationOutput {
- std::move(outPath),
- (ingestionMethod == FileIngestionMethod::Recursive ? "r:" : "")
- + printHashType(h.type),
- h.to_string(Base::Base16, false),
- });
+ drv.outputs.insert_or_assign("out", DerivationOutput(
+ std::move(outPath),
+ FileSystemHash(ingestionMethod, std::move(h))));
}
else {
@@ -741,7 +738,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
for (auto & i : outputs) {
if (!jsonObject) drv.env[i] = "";
drv.outputs.insert_or_assign(i,
- DerivationOutput(StorePath::dummy.clone(), "", ""));
+ DerivationOutput(StorePath::dummy.clone(), std::optional<FileSystemHash>()));
}
Hash h = hashDerivationModulo(*state.store, Derivation(drv), true);
@@ -750,7 +747,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
auto outPath = state.store->makeOutputPath(i, h, drvName);
if (!jsonObject) drv.env[i] = state.store->printStorePath(outPath);
drv.outputs.insert_or_assign(i,
- DerivationOutput(std::move(outPath), "", ""));
+ DerivationOutput(std::move(outPath), std::optional<FileSystemHash>()));
}
}
diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index ae7ba6549..e35044532 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -3712,10 +3712,7 @@ void DerivationGoal::registerOutputs()
if (fixedOutput) {
- FileIngestionMethod outputHashMode; Hash h;
- i.second.parseHashInfo(outputHashMode, h);
-
- if (outputHashMode == FileIngestionMethod::Flat) {
+ if (i.second.hash->method == FileIngestionMethod::Flat) {
/* The output path should be a regular file without execute permission. */
if (!S_ISREG(st.st_mode) || (st.st_mode & S_IXUSR) != 0)
throw BuildError(
@@ -3725,20 +3722,22 @@ void DerivationGoal::registerOutputs()
/* Check the hash. In hash mode, move the path produced by
the derivation to its content-addressed location. */
- Hash h2 = outputHashMode == FileIngestionMethod::Recursive
- ? hashPath(h.type, actualPath).first
- : hashFile(h.type, actualPath);
+ Hash h2 = i.second.hash->method == FileIngestionMethod::Recursive
+ ? hashPath(i.second.hash->hash.type, actualPath).first
+ : hashFile(i.second.hash->hash.type, actualPath);
- auto dest = worker.store.makeFixedOutputPath(outputHashMode, h2, i.second.path.name());
+ auto dest = worker.store.makeFixedOutputPath(i.second.hash->method, h2, i.second.path.name());
- if (h != h2) {
+ if (i.second.hash->hash != h2) {
/* Throw an error after registering the path as
valid. */
worker.hashMismatch = true;
delayedException = std::make_exception_ptr(
BuildError("hash mismatch in fixed-output derivation '%s':\n wanted: %s\n got: %s",
- worker.store.printStorePath(dest), h.to_string(Base::SRI), h2.to_string(Base::SRI)));
+ worker.store.printStorePath(dest),
+ i.second.hash->hash.to_string(Base::SRI),
+ h2.to_string(Base::SRI)));
Path actualDest = worker.store.Store::toRealPath(dest);
@@ -3758,7 +3757,7 @@ void DerivationGoal::registerOutputs()
else
assert(worker.store.parseStorePath(path) == dest);
- ca = makeFixedOutputCA(outputHashMode, h2);
+ ca = makeFixedOutputCA(i.second.hash->method, h2);
}
/* Get rid of all weird permissions. This also checks that
diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc
index a90c9b86c..ad4d02c2c 100644
--- a/src/libstore/derivations.cc
+++ b/src/libstore/derivations.cc
@@ -8,22 +8,8 @@
namespace nix {
-
-void DerivationOutput::parseHashInfo(FileIngestionMethod & recursive, Hash & hash) const
-{
- recursive = FileIngestionMethod::Flat;
- string algo = hashAlgo;
-
- if (string(algo, 0, 2) == "r:") {
- recursive = FileIngestionMethod::Recursive;
- algo = string(algo, 2);
- }
-
- HashType hashType = parseHashType(algo);
- if (hashType == HashType::Unknown)
- throw Error("unknown hash algorithm '%s'", algo);
-
- hash = Hash(this->hash, hashType);
+std::string FileSystemHash::printMethodAlgo() const {
+ return makeFileIngestionPrefix(method) + printHashType(hash.type);
}
@@ -35,7 +21,7 @@ BasicDerivation::BasicDerivation(const BasicDerivation & other)
{
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)));
+ DerivationOutput(i.second.path.clone(), std::optional<FileSystemHash>(i.second.hash)));
for (auto & i : other.inputSrcs)
inputSrcs.insert(i.clone());
}
@@ -142,6 +128,33 @@ static StringSet parseStrings(std::istream & str, bool arePaths)
}
+static DerivationOutput parseDerivationOutput(const Store & store, istringstream_nocopy & str)
+{
+ expect(str, ","); auto path = store.parseStorePath(parsePath(str));
+ expect(str, ","); auto hashAlgo = parseString(str);
+ expect(str, ","); const auto hash = parseString(str);
+ expect(str, ")");
+
+ auto method = FileIngestionMethod::Flat;
+ std::optional<FileSystemHash> fsh;
+ if (hashAlgo != "") {
+ if (string(hashAlgo, 0, 2) == "r:") {
+ method = FileIngestionMethod::Recursive;
+ hashAlgo = string(hashAlgo, 2);
+ }
+ const HashType hashType = parseHashType(hashAlgo);
+ if (hashType == HashType::Unknown)
+ throw Error("unknown hash hashAlgorithm '%s'", hashAlgo);
+ fsh = FileSystemHash {
+ std::move(method),
+ Hash(hash, hashType),
+ };
+ }
+
+ return DerivationOutput(std::move(path), std::move(fsh));
+}
+
+
static Derivation parseDerivation(const Store & store, const string & s)
{
Derivation drv;
@@ -151,11 +164,7 @@ static Derivation parseDerivation(const Store & store, const string & s)
/* Parse the list of outputs. */
while (!endOfList(str)) {
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);
- expect(str, ")");
- drv.outputs.emplace(id, DerivationOutput(std::move(path), std::move(hashAlgo), std::move(hash)));
+ drv.outputs.emplace(id, parseDerivationOutput(store, str));
}
/* Parse the list of input derivations. */
@@ -275,8 +284,9 @@ string Derivation::unparse(const Store & store, bool maskOutputs,
if (first) first = false; else s += ',';
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);
+ s += ','; printUnquotedString(s, i.second.hash ? i.second.hash->printMethodAlgo() : "");
+ s += ','; printUnquotedString(s,
+ i.second.hash ? i.second.hash->hash.to_string(Base::Base16, false) : "");
s += ')';
}
@@ -332,7 +342,7 @@ bool BasicDerivation::isFixedOutput() const
{
return outputs.size() == 1 &&
outputs.begin()->first == "out" &&
- outputs.begin()->second.hash != "";
+ outputs.begin()->second.hash;
}
@@ -365,8 +375,8 @@ Hash hashDerivationModulo(Store & store, const Derivation & drv, bool maskOutput
if (drv.isFixedOutput()) {
DerivationOutputs::const_iterator i = drv.outputs.begin();
return hashString(HashType::SHA256, "fixed:out:"
- + i->second.hashAlgo + ":"
- + i->second.hash + ":"
+ + i->second.hash->printMethodAlgo() + ":"
+ + i->second.hash->hash.to_string(Base::Base16, false) + ":"
+ store.printStorePath(i->second.path));
}
@@ -409,6 +419,30 @@ StorePathSet BasicDerivation::outputPaths() const
return paths;
}
+static DerivationOutput readDerivationOutput(Source & in, const Store & store)
+{
+ auto path = store.parseStorePath(readString(in));
+ auto hashAlgo = readString(in);
+ const auto hash = readString(in);
+
+ auto method = FileIngestionMethod::Flat;
+ std::optional<FileSystemHash> fsh;
+ if (hashAlgo != "") {
+ if (string(hashAlgo, 0, 2) == "r:") {
+ method = FileIngestionMethod::Recursive;
+ hashAlgo = string(hashAlgo, 2);
+ }
+ HashType hashType = parseHashType(hashAlgo);
+ if (hashType == HashType::Unknown)
+ throw Error("unknown hash hashAlgorithm '%s'", hashAlgo);
+ fsh = FileSystemHash {
+ std::move(method),
+ Hash(hash, hashType),
+ };
+ }
+
+ return DerivationOutput(std::move(path), std::move(fsh));
+}
Source & readDerivation(Source & in, const Store & store, BasicDerivation & drv)
{
@@ -416,10 +450,8 @@ Source & readDerivation(Source & in, const Store & store, BasicDerivation & drv)
auto nr = readNum<size_t>(in);
for (size_t n = 0; n < nr; n++) {
auto name = readString(in);
- 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)));
+ auto output = readDerivationOutput(in, store);
+ drv.outputs.emplace(name, output);
}
drv.inputSrcs = readStorePaths<StorePathSet>(store, in);
@@ -441,7 +473,10 @@ void writeDerivation(Sink & out, const Store & store, const BasicDerivation & dr
{
out << drv.outputs.size();
for (auto & i : drv.outputs)
- out << i.first << store.printStorePath(i.second.path) << i.second.hashAlgo << i.second.hash;
+ out << i.first
+ << store.printStorePath(i.second.path)
+ << i.second.hash->printMethodAlgo()
+ << i.second.hash->hash.to_string(Base::Base16, false);
writeStorePaths(store, out, drv.inputSrcs);
out << drv.platform << drv.builder << drv.args;
out << drv.env.size();
diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index b1224b93b..46de3960e 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -12,16 +12,31 @@ namespace nix {
/* Abstract syntax of derivations. */
+/// Pair of a hash, and how the file system was ingested
+struct FileSystemHash {
+ FileIngestionMethod method;
+ Hash hash;
+ FileSystemHash(FileIngestionMethod method, Hash hash)
+ : method(std::move(method))
+ , hash(std::move(hash))
+ { }
+ FileSystemHash(const FileSystemHash &) = default;
+ FileSystemHash(FileSystemHash &&) = default;
+ FileSystemHash & operator = (const FileSystemHash &) = default;
+ std::string printMethodAlgo() const;
+};
+
struct DerivationOutput
{
StorePath path;
- std::string hashAlgo; /* hash used for expected hash computation */
- std::string hash; /* expected hash, may be null */
- DerivationOutput(StorePath && path, std::string && hashAlgo, std::string && hash)
+ std::optional<FileSystemHash> hash; /* hash used for expected hash computation */
+ DerivationOutput(StorePath && path, std::optional<FileSystemHash> && hash)
: path(std::move(path))
- , hashAlgo(std::move(hashAlgo))
, hash(std::move(hash))
{ }
+ DerivationOutput(const DerivationOutput &) = default;
+ DerivationOutput(DerivationOutput &&) = default;
+ DerivationOutput & operator = (const DerivationOutput &) = default;
void parseHashInfo(FileIngestionMethod & recursive, Hash & hash) const;
};
diff --git a/src/libstore/local-store.cc b/src/libstore/local-store.cc
index 7f0d5af25..9b60bf887 100644
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -557,10 +557,12 @@ void LocalStore::checkDerivationOutputs(const StorePath & drvPath, const Derivat
if (out == drv.outputs.end())
throw Error("derivation '%s' does not have an output named 'out'", printStorePath(drvPath));
- FileIngestionMethod method; Hash h;
- out->second.parseHashInfo(method, h);
-
- check(makeFixedOutputPath(method, h, drvName), out->second.path, "out");
+ check(
+ makeFixedOutputPath(
+ out->second.hash->method,
+ out->second.hash->hash,
+ drvName),
+ out->second.path, "out");
}
else {
diff --git a/src/libstore/nar-info.cc b/src/libstore/nar-info.cc
index a35886302..8592ee968 100644
--- a/src/libstore/nar-info.cc
+++ b/src/libstore/nar-info.cc
@@ -4,7 +4,7 @@
namespace nix {
NarInfo::NarInfo(const Store & store, const std::string & s, const std::string & whence)
- : ValidPathInfo(StorePath::dummy.clone()) // FIXME: hack
+ : ValidPathInfo(StorePath::dummy) // FIXME: hack
{
auto corrupt = [&]() {
throw Error(format("NAR info file '%1%' is corrupt") % whence);
diff --git a/src/libstore/path.hh b/src/libstore/path.hh
index 5122e7422..f3ed6ca39 100644
--- a/src/libstore/path.hh
+++ b/src/libstore/path.hh
@@ -13,6 +13,7 @@ extern "C" {
void ffi_StorePath_drop(void *);
bool ffi_StorePath_less_than(const StorePath & a, const StorePath & b);
bool ffi_StorePath_eq(const StorePath & a, const StorePath & b);
+ void ffi_StorePath_clone_to(const StorePath & _other, StorePath & _this);
unsigned char * ffi_StorePath_hash_data(const StorePath & p);
}
@@ -43,6 +44,19 @@ struct StorePath : rust::Value<3 * sizeof(void *) + 24, ffi_StorePath_drop>
return !(*this == other);
}
+ StorePath(StorePath && that) = default;
+
+ StorePath(const StorePath & that)
+ {
+ ffi_StorePath_clone_to(that, *this);
+ }
+
+ void operator = (const StorePath & that)
+ {
+ (rust::Value<3 * sizeof(void *) + 24, ffi_StorePath_drop>::operator = (that));
+ ffi_StorePath_clone_to(that, *this);
+ }
+
StorePath clone() const;
/* Check whether a file name ends with the extension for
diff --git a/src/libstore/store-api.cc b/src/libstore/store-api.cc
index ff4832ffa..b7ba9e4f2 100644
--- a/src/libstore/store-api.cc
+++ b/src/libstore/store-api.cc
@@ -172,22 +172,19 @@ static std::string makeType(
StorePath Store::makeFixedOutputPath(
- FileIngestionMethod recursive,
+ FileIngestionMethod method,
const Hash & hash,
std::string_view name,
const StorePathSet & references,
bool hasSelfReference) const
{
- if (hash.type == HashType::SHA256 && recursive == FileIngestionMethod::Recursive) {
+ if (hash.type == HashType::SHA256 && method == FileIngestionMethod::Recursive) {
return makeStorePath(makeType(*this, "source", references, hasSelfReference), hash, name);
} else {
assert(references.empty());
- return makeStorePath("output:out",
- hashString(HashType::SHA256,
- "fixed:out:"
- + (recursive == FileIngestionMethod::Recursive ? (string) "r:" : "")
- + hash.to_string(Base::Base16) + ":"),
- name);
+ return makeStorePath("output:out", hashString(HashType::SHA256,
+ "fixed:out:" + makeFileIngestionPrefix(method) +
+ hash.to_string(Base::Base16) + ":"), name);
}
}
@@ -693,21 +690,6 @@ void copyClosure(ref<Store> srcStore, ref<Store> dstStore,
}
-ValidPathInfo::ValidPathInfo(const ValidPathInfo & other)
- : path(other.path.clone())
- , deriver(other.deriver ? other.deriver->clone(): std::optional<StorePath>{})
- , narHash(other.narHash)
- , references(cloneStorePathSet(other.references))
- , registrationTime(other.registrationTime)
- , narSize(other.narSize)
- , id(other.id)
- , ultimate(other.ultimate)
- , sigs(other.sigs)
- , ca(other.ca)
-{
-}
-
-
std::optional<ValidPathInfo> decodeValidPathInfo(const Store & store, std::istream & str, bool hashGiven)
{
std::string path;
@@ -832,10 +814,21 @@ Strings ValidPathInfo::shortRefs() const
}
-std::string makeFixedOutputCA(FileIngestionMethod recursive, const Hash & hash)
+std::string makeFileIngestionPrefix(const FileIngestionMethod m) {
+ switch (m) {
+ case FileIngestionMethod::Flat:
+ return "";
+ case FileIngestionMethod::Recursive:
+ return "r:";
+ default:
+ throw Error("impossible, caught both cases");
+ }
+}
+
+std::string makeFixedOutputCA(FileIngestionMethod method, const Hash & hash)
{
return "fixed:"
- + (recursive == FileIngestionMethod::Recursive ? (std::string) "r:" : "")
+ + makeFileIngestionPrefix(method)
+ hash.to_string();
}
diff --git a/src/libstore/store-api.hh b/src/libstore/store-api.hh
index 46dd261df..00ecf0bd9 100644
--- a/src/libstore/store-api.hh
+++ b/src/libstore/store-api.hh
@@ -189,8 +189,9 @@ struct ValidPathInfo
Strings shortRefs() const;
- ValidPathInfo(StorePath && path) : path(std::move(path)) { }
- explicit ValidPathInfo(const ValidPathInfo & other);
+ ValidPathInfo(StorePath && path) : path(std::move(path)) { };
+ ValidPathInfo(const StorePath & path) : path(path) { };
+ ValidPathInfo(const ValidPathInfo & other) = default;
virtual ~ValidPathInfo() { }
};
@@ -847,6 +848,9 @@ std::optional<ValidPathInfo> decodeValidPathInfo(
std::istream & str,
bool hashGiven = false);
+/* Compute the prefix to the hash algorithm which indicates how the files were
+ ingested. */
+std::string makeFileIngestionPrefix(const FileIngestionMethod m);
/* Compute the content-addressability assertion (ValidPathInfo::ca)
for paths created by makeFixedOutputPath() / addToStore(). */
diff --git a/src/libutil/hash.hh b/src/libutil/hash.hh
index 0fe6e7677..da557e585 100644
--- a/src/libutil/hash.hh
+++ b/src/libutil/hash.hh
@@ -55,6 +55,12 @@ struct Hash
string. */
Hash(const std::string & s, HashType type = HashType::Unknown);
+ Hash(const Hash &) = default;
+
+ Hash(Hash &&) = default;
+
+ Hash & operator = (const Hash &) = default;
+
void init();
/* Check whether a hash is set. */
diff --git a/src/libutil/rust-ffi.hh b/src/libutil/rust-ffi.hh
index 228e2eead..8b61b6d00 100644
--- a/src/libutil/rust-ffi.hh
+++ b/src/libutil/rust-ffi.hh
@@ -30,7 +30,10 @@ protected:
// Must not be called directly.
Value()
- { }
+ {
+ // Precaution, in case this is used improperly
+ evacuate();
+ }
Value(Value && other)
: raw(other.raw)
@@ -38,6 +41,19 @@ protected:
other.evacuate();
}
+ // Not all Rust types are Clone / Copy, but our base Value class needs to
+ // have a copy constructor so that types which do implement Copy/Clone
+ // can be copied/cloned.
+ Value(const Value & other)
+ : raw(other.raw)
+ {
+ }
+ void operator =(const Value & other)
+ {
+ if (!isEvacuated())
+ drop(this);
+ }
+
void operator =(Value && other)
{
if (!isEvacuated())
@@ -76,6 +92,16 @@ struct Vec : Value<3 * sizeof(void *), drop>
{
return ((const T * *) &this->raw)[0];
}
+
+protected:
+
+ // Must not be called directly.
+ Vec<T, drop>();
+
+ Vec<T, drop>(Vec<T, drop> && other) = default;
+
+ // Delete until we know how to do this properly.
+ Vec<T, drop>(const Vec<T, drop> & other) = delete;
};
/* A Rust slice. */
@@ -144,7 +170,7 @@ struct Result
std::exception_ptr * exc;
};
- Result() : tag(Uninit) { }; // FIXME: remove
+ Result() = delete;
Result(const Result &) = delete;
@@ -171,7 +197,7 @@ struct Result
}
/* Rethrow the wrapped exception or return the wrapped value. */
- T unwrap()
+ T unwrap() &&
{
if (tag == Ok) {
tag = Uninit;
diff --git a/src/libutil/tests/libutil-tests b/src/libutil/tests/libutil-tests
new file mode 100755
index 000000000..919c401a1
--- /dev/null
+++ b/src/libutil/tests/libutil-tests
Binary files differ
diff --git a/src/nix/dev-shell.cc b/src/nix/dev-shell.cc
index d300f6a23..337d7750e 100644
--- a/src/nix/dev-shell.cc
+++ b/src/nix/dev-shell.cc
@@ -135,7 +135,9 @@ StorePath getDerivationEnvironment(ref<Store> store, const StorePath & drvPath)
drv.inputSrcs.insert(std::move(getEnvShPath));
Hash h = hashDerivationModulo(*store, drv, true);
auto shellOutPath = store->makeOutputPath("out", h, drvName);
- drv.outputs.insert_or_assign("out", DerivationOutput(shellOutPath.clone(), "", ""));
+ drv.outputs.insert_or_assign("out", DerivationOutput(shellOutPath.clone(), FileSystemHash {
+ FileIngestionMethod::Flat, Hash { }
+ }));
drv.env["out"] = store->printStorePath(shellOutPath);
auto shellDrvPath2 = writeDerivation(store, drv, drvName);
diff --git a/src/nix/show-derivation.cc b/src/nix/show-derivation.cc
index 22c569f3c..87387002d 100644
--- a/src/nix/show-derivation.cc
+++ b/src/nix/show-derivation.cc
@@ -72,9 +72,9 @@ struct CmdShowDerivation : InstallablesCommand
for (auto & output : drv.outputs) {
auto outputObj(outputsObj.object(output.first));
outputObj.attr("path", store->printStorePath(output.second.path));
- if (output.second.hash != "") {
- outputObj.attr("hashAlgo", output.second.hashAlgo);
- outputObj.attr("hash", output.second.hash);
+ if (output.second.hash) {
+ outputObj.attr("hashAlgo", output.second.hash->printMethodAlgo());
+ outputObj.attr("hash", output.second.hash->hash.to_string(Base::Base16, false));
}
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 13:43:37 +0000