nixos/nix
1
1
Fork 0
mirror of https://github.com/NixOS/nix.git synced 2025-11-08 19:46:02 +01:00
Code Activity

Revert "Merge pull request #14097 from obsidiansystems/light-realisation-improvements"

Browse source 
This reverts commit dc8c1461da, reversing
changes made to 28adcfda32.
This commit is contained in:
Sergei Zimmerman 2025-10-05 21:54:32 +03:00
parent 7ba3ef21a6
commit 7e39ab4dc7
No known key found for this signature in database
32 changed files with 254 additions and 423 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/libcmd/built-path.cc
View file

@ -117,11 +117,10 @@ RealisedPath::Set BuiltPath::toRealisedPaths(Store & store) const
"the derivation '%s' has unrealised output '%s' (derived-path.cc/toRealisedPaths)",
store.printStorePath(p.drvPath->outPath()),
outputName);
DrvOutput key{*drvOutput, outputName};
auto thisRealisation = store.queryRealisation(key);
auto thisRealisation = store.queryRealisation(DrvOutput{*drvOutput, outputName});
assert(thisRealisation); // We’ve built it, so we must
// have the realisation
res.insert(Realisation{*thisRealisation, std::move(key)});
res.insert(*thisRealisation);
} else {
res.insert(outputPath);
}

44
src/libstore-tests/common-protocol.cc
View file

@ -112,34 +112,32 @@ CHARACTERIZATION_TEST(
"realisation",
(std::tuple<Realisation, Realisation>{
Realisation{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.id =
DrvOutput{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
},
Realisation{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
.dependentRealisations =
.id =
{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
.dependentRealisations =
{
{
{
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "quux",
},
StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "quux",
},
StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
},
},
}))

15
src/libstore-tests/dummy-store.cc
View file

@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include "nix/store/dummy-store-impl.hh"
#include "nix/store/dummy-store.hh"
#include "nix/store/globals.hh"
#include "nix/store/realisation.hh"
@ -13,7 +13,7 @@ TEST(DummyStore, realisation_read)
auto store = [] {
auto cfg = make_ref<DummyStoreConfig>(StoreReference::Params{});
cfg->readOnly = false;
return cfg->openDummyStore();
return cfg->openStore();
}();
auto drvHash = Hash::parseExplicitFormatUnprefixed(
@ -22,17 +22,6 @@ TEST(DummyStore, realisation_read)
auto outputName = "foo";
EXPECT_EQ(store->queryRealisation({drvHash, outputName}), nullptr);
UnkeyedRealisation value{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv"},
};
store->buildTrace.insert({drvHash, {{outputName, make_ref<UnkeyedRealisation>(value)}}});
auto value2 = store->queryRealisation({drvHash, outputName});
ASSERT_TRUE(value2);
EXPECT_EQ(*value2, value);
}
} // namespace nix

20
src/libstore-tests/realisation.cc
View file

@ -49,16 +49,16 @@ INSTANTIATE_TEST_SUITE_P(
RealisationJsonTest,
([] {
Realisation simple{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv"},
},
{
.drvHash = Hash::parseExplicitFormatUnprefixed(
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
HashAlgorithm::SHA256,
HashFormat::Base16),
.outputName = "foo",
},
.id =
{
.drvHash = Hash::parseExplicitFormatUnprefixed(
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
HashAlgorithm::SHA256,
HashFormat::Base16),
.outputName = "foo",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv"},
};
return ::testing::Values(
std::pair{

74
src/libstore-tests/serve-protocol.cc
View file

@ -95,34 +95,32 @@ VERSIONED_CHARACTERIZATION_TEST(
defaultVersion,
(std::tuple<Realisation, Realisation>{
Realisation{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
},
{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.id =
DrvOutput{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
},
Realisation{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
.dependentRealisations =
.id =
{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
.dependentRealisations =
{
{
{
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "quux",
},
StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "quux",
},
StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
},
},
}))
@ -198,27 +196,25 @@ VERSIONED_CHARACTERIZATION_TEST(
{
"foo",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
{
"bar",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
},
},

132
src/libstore-tests/worker-protocol.cc
View file

@ -148,34 +148,32 @@ VERSIONED_CHARACTERIZATION_TEST(
defaultVersion,
(std::tuple<Realisation, Realisation>{
Realisation{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.id =
DrvOutput{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
},
Realisation{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
.dependentRealisations =
.id =
{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
.signatures = {"asdf", "qwer"},
.dependentRealisations =
{
{
{
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "quux",
},
StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "quux",
},
StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
.outputName = "baz",
},
},
},
}))
@ -216,25 +214,25 @@ VERSIONED_CHARACTERIZATION_TEST(
{
"foo",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
{
"bar",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
DrvOutput{
.drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
},
},
@ -269,27 +267,25 @@ VERSIONED_CHARACTERIZATION_TEST(
{
"foo",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
{
"bar",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
},
},
@ -328,27 +324,25 @@ VERSIONED_CHARACTERIZATION_TEST(
{
"foo",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "foo",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo"},
},
},
{
"bar",
{
{
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.id =
DrvOutput{
.drvHash =
Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
.outputName = "bar",
},
.outPath = StorePath{"g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar"},
},
},
},

19
src/libstore/binary-cache-store.cc
View file

@ -502,15 +502,10 @@ StorePath BinaryCacheStore::addToStore(
->path;
}
std::string BinaryCacheStore::makeRealisationPath(const DrvOutput & id)
{
return realisationsPrefix + "/" + id.to_string() + ".doi";
}
void BinaryCacheStore::queryRealisationUncached(
const DrvOutput & id, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept
const DrvOutput & id, Callback<std::shared_ptr<const Realisation>> callback) noexcept
{
auto outputInfoFilePath = makeRealisationPath(id);
auto outputInfoFilePath = realisationsPrefix + "/" + id.to_string() + ".doi";
auto callbackPtr = std::make_shared<decltype(callback)>(std::move(callback));
@ -520,12 +515,11 @@ void BinaryCacheStore::queryRealisationUncached(
if (!data)
return (*callbackPtr)({});
std::shared_ptr<const UnkeyedRealisation> realisation;
std::shared_ptr<const Realisation> realisation;
try {
realisation = std::make_shared<const UnkeyedRealisation>(nlohmann::json::parse(*data));
realisation = std::make_shared<const Realisation>(nlohmann::json::parse(*data));
} catch (Error & e) {
e.addTrace(
{}, "while parsing file '%s' as a realisation for key '%s'", outputInfoFilePath, id.to_string());
e.addTrace({}, "while parsing file '%s' as a realisation", outputInfoFilePath);
throw;
}
return (*callbackPtr)(std::move(realisation));
@ -541,7 +535,8 @@ void BinaryCacheStore::registerDrvOutput(const Realisation & info)
{
if (diskCache)
diskCache->upsertRealisation(config.getReference().render(/*FIXME withParams=*/false), info);
upsertFile(makeRealisationPath(info.id), static_cast<nlohmann::json>(info).dump(), "application/json");
auto filePath = realisationsPrefix + "/" + info.id.to_string() + ".doi";
upsertFile(filePath, static_cast<nlohmann::json>(info).dump(), "application/json");
}
ref<RemoteFSAccessor> BinaryCacheStore::getRemoteFSAccessor(bool requireValidPath)

13
src/libstore/build/derivation-building-goal.cc
View file

@ -1092,22 +1092,13 @@ DerivationBuildingGoal::checkPathValidity(std::map<std::string, InitialOutput> &
// without the `ca-derivations` experimental flag).
worker.store.registerDrvOutput(
Realisation{
{
.outPath = info.known->path,
},
drvOutput,
info.known->path,
});
}
}
if (info.known && info.known->isValid())
validOutputs.emplace(
i.first,
Realisation{
{
.outPath = info.known->path,
},
drvOutput,
});
validOutputs.emplace(i.first, Realisation{drvOutput, info.known->path});
}
bool allValid = true;

59
src/libstore/build/derivation-goal.cc
View file

@ -190,17 +190,13 @@ Goal::Co DerivationGoal::haveDerivation(bool storeDerivation)
auto realisation = [&] {
auto take1 = get(success.builtOutputs, wantedOutput);
if (take1)
return static_cast<UnkeyedRealisation>(*take1);
return *take1;
/* The above `get` should work. But stateful tracking of
outputs in resolvedResult, this can get out of sync with the
store, which is our actual source of truth. For now we just
check the store directly if it fails. */
auto take2 = worker.evalStore.queryRealisation(
DrvOutput{
.drvHash = *resolvedHash,
.outputName = wantedOutput,
});
auto take2 = worker.evalStore.queryRealisation(DrvOutput{*resolvedHash, wantedOutput});
if (take2)
return *take2;
@ -211,12 +207,8 @@ Goal::Co DerivationGoal::haveDerivation(bool storeDerivation)
}();
if (!drv->type().isImpure()) {
Realisation newRealisation{
realisation,
{
.drvHash = *outputHash,
.outputName = wantedOutput,
}};
auto newRealisation = realisation;
newRealisation.id = DrvOutput{*outputHash, wantedOutput};
newRealisation.signatures.clear();
if (!drv->type().isFixed()) {
auto & drvStore = worker.evalStore.isValidPath(drvPath) ? worker.evalStore : worker.store;
@ -266,16 +258,7 @@ Goal::Co DerivationGoal::haveDerivation(bool storeDerivation)
/* In checking mode, the builder will not register any outputs.
So we want to make sure the ones that we wanted to check are
properly there. */
success.builtOutputs = {{
wantedOutput,
{
assertPathValidity(),
{
.drvHash = outputHash,
.outputName = wantedOutput,
},
},
}};
success.builtOutputs = {{wantedOutput, assertPathValidity()}};
} else {
/* Otherwise the builder will give us info for out output, but
also for other outputs. Filter down to just our output so as
@ -390,20 +373,18 @@ Goal::Co DerivationGoal::repairClosure()
co_return doneSuccess(BuildResult::Success::AlreadyValid, assertPathValidity());
}
std::optional<std::pair<UnkeyedRealisation, PathStatus>> DerivationGoal::checkPathValidity()
std::optional<std::pair<Realisation, PathStatus>> DerivationGoal::checkPathValidity()
{
if (drv->type().isImpure())
return std::nullopt;
auto drvOutput = DrvOutput{outputHash, wantedOutput};
std::optional<UnkeyedRealisation> mRealisation;
std::optional<Realisation> mRealisation;
if (auto * mOutput = get(drv->outputs, wantedOutput)) {
if (auto mPath = mOutput->path(worker.store, drv->name, wantedOutput)) {
mRealisation = UnkeyedRealisation{
.outPath = std::move(*mPath),
};
mRealisation = Realisation{drvOutput, std::move(*mPath)};
}
} else {
throw Error(
@ -431,14 +412,7 @@ std::optional<std::pair<UnkeyedRealisation, PathStatus>> DerivationGoal::checkPa
// derivation, and the output path is valid, but we don't have
// its realisation stored (probably because it has been built
// without the `ca-derivations` experimental flag).
worker.store.registerDrvOutput(
Realisation{
*mRealisation,
{
.drvHash = outputHash,
.outputName = wantedOutput,
},
});
worker.store.registerDrvOutput(*mRealisation);
}
return {{*mRealisation, status}};
@ -446,7 +420,7 @@ std::optional<std::pair<UnkeyedRealisation, PathStatus>> DerivationGoal::checkPa
return std::nullopt;
}
UnkeyedRealisation DerivationGoal::assertPathValidity()
Realisation DerivationGoal::assertPathValidity()
{
auto checkResult = checkPathValidity();
if (!(checkResult && checkResult->second == PathStatus::Valid))
@ -454,20 +428,11 @@ UnkeyedRealisation DerivationGoal::assertPathValidity()
return checkResult->first;
}
Goal::Done DerivationGoal::doneSuccess(BuildResult::Success::Status status, UnkeyedRealisation builtOutput)
Goal::Done DerivationGoal::doneSuccess(BuildResult::Success::Status status, Realisation builtOutput)
{
buildResult.inner = BuildResult::Success{
.status = status,
.builtOutputs = {{
wantedOutput,
{
std::move(builtOutput),
DrvOutput{
.drvHash = outputHash,
.outputName = wantedOutput,
},
},
}},
.builtOutputs = {{wantedOutput, std::move(builtOutput)}},
};
mcExpectedBuilds.reset();

10
src/libstore/build/drv-output-substitution-goal.cc
View file

@ -43,10 +43,10 @@ Goal::Co DrvOutputSubstitutionGoal::init()
outPipe->createAsyncPipe(worker.ioport.get());
#endif
auto promise = std::make_shared<std::promise<std::shared_ptr<const UnkeyedRealisation>>>();
auto promise = std::make_shared<std::promise<std::shared_ptr<const Realisation>>>();
sub->queryRealisation(
id, {[outPipe(outPipe), promise(promise)](std::future<std::shared_ptr<const UnkeyedRealisation>> res) {
id, {[outPipe(outPipe), promise(promise)](std::future<std::shared_ptr<const Realisation>> res) {
try {
Finally updateStats([&]() { outPipe->writeSide.close(); });
promise->set_value(res.get());
@ -75,7 +75,7 @@ Goal::Co DrvOutputSubstitutionGoal::init()
* The realisation corresponding to the given output id.
* Will be filled once we can get it.
*/
std::shared_ptr<const UnkeyedRealisation> outputInfo;
std::shared_ptr<const Realisation> outputInfo;
try {
outputInfo = promise->get_future().get();
@ -132,7 +132,7 @@ Goal::Co DrvOutputSubstitutionGoal::init()
}
Goal::Co DrvOutputSubstitutionGoal::realisationFetched(
Goals waitees, std::shared_ptr<const UnkeyedRealisation> outputInfo, nix::ref<nix::Store> sub)
Goals waitees, std::shared_ptr<const Realisation> outputInfo, nix::ref<nix::Store> sub)
{
waitees.insert(worker.makePathSubstitutionGoal(outputInfo->outPath));
@ -145,7 +145,7 @@ Goal::Co DrvOutputSubstitutionGoal::realisationFetched(
co_return amDone(nrNoSubstituters > 0 ? ecNoSubstituters : ecFailed);
}
worker.store.registerDrvOutput({*outputInfo, id});
worker.store.registerDrvOutput(*outputInfo);
trace("finished");
co_return amDone(ecSuccess);

4
src/libstore/daemon.cc
View file

@ -964,7 +964,7 @@ static void performOp(
if (GET_PROTOCOL_MINOR(conn.protoVersion) < 31) {
auto outputId = DrvOutput::parse(readString(conn.from));
auto outputPath = StorePath(readString(conn.from));
store->registerDrvOutput(Realisation{{.outPath = outputPath}, outputId});
store->registerDrvOutput(Realisation{.id = outputId, .outPath = outputPath});
} else {
auto realisation = WorkerProto::Serialise<Realisation>::read(*store, rconn);
store->registerDrvOutput(realisation);
@ -986,7 +986,7 @@ static void performOp(
} else {
std::set<Realisation> realisations;
if (info)
realisations.insert({*info, outputId});
realisations.insert(*info);
WorkerProto::write(*store, wconn, realisations);
}
break;

21
src/libstore/dummy-store.cc
View file

@ -3,7 +3,6 @@
#include "nix/util/callback.hh"
#include "nix/util/memory-source-accessor.hh"
#include "nix/store/dummy-store-impl.hh"
#include "nix/store/realisation.hh"
#include <boost/unordered/concurrent_flat_map.hpp>
@ -252,10 +251,7 @@ struct DummyStoreImpl : DummyStore
void registerDrvOutput(const Realisation & output) override
{
auto ref = make_ref<UnkeyedRealisation>(output);
buildTrace.insert_or_visit({output.id.drvHash, {{output.id.outputName, ref}}}, [&](auto & kv) {
kv.second.insert_or_assign(output.id.outputName, make_ref<UnkeyedRealisation>(output));
});
unsupported("registerDrvOutput");
}
void narFromPath(const StorePath & path, Sink & sink) override
@ -270,19 +266,10 @@ struct DummyStoreImpl : DummyStore
throw Error("path '%s' is not valid", printStorePath(path));
}
void queryRealisationUncached(
const DrvOutput & drvOutput, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override
void
queryRealisationUncached(const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept override
{
bool visited = false;
buildTrace.cvisit(drvOutput.drvHash, [&](const auto & kv) {
if (auto it = kv.second.find(drvOutput.outputName); it != kv.second.end()) {
visited = true;
callback(it->second.get_ptr());
}
});
if (!visited)
callback(nullptr);
callback(nullptr);
}
std::shared_ptr<SourceAccessor> getFSAccessor(const StorePath & path, bool requireValidPath) override

17
src/libstore/include/nix/store/binary-cache-store.hh
View file

@ -80,22 +80,13 @@ private:
protected:
/**
* The prefix under which realisation infos will be stored
*/
constexpr const static std::string realisationsPrefix = "realisations";
// The prefix under which realisation infos will be stored
const std::string realisationsPrefix = "realisations";
constexpr const static std::string cacheInfoFile = "nix-cache-info";
const std::string cacheInfoFile = "nix-cache-info";
BinaryCacheStore(Config &);
/**
* Compute the path to the given realisation
*
* It's `${realisationsPrefix}/${drvOutput}.doi`.
*/
std::string makeRealisationPath(const DrvOutput & id);
public:
virtual bool fileExists(const std::string & path) = 0;
@ -184,7 +175,7 @@ public:
void registerDrvOutput(const Realisation & info) override;
void queryRealisationUncached(
const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override;
const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
void narFromPath(const StorePath & path, Sink & sink) override;

6
src/libstore/include/nix/store/build/derivation-goal.hh
View file

@ -93,17 +93,17 @@ private:
* of the wanted output, and a `PathStatus` with the
* current status of that output.
*/
std::optional<std::pair<UnkeyedRealisation, PathStatus>> checkPathValidity();
std::optional<std::pair<Realisation, PathStatus>> checkPathValidity();
/**
* Aborts if any output is not valid or corrupt, and otherwise
* returns a 'Realisation' for the wanted output.
*/
UnkeyedRealisation assertPathValidity();
Realisation assertPathValidity();
Co repairClosure();
Done doneSuccess(BuildResult::Success::Status status, UnkeyedRealisation builtOutput);
Done doneSuccess(BuildResult::Success::Status status, Realisation builtOutput);
Done doneFailure(BuildError ex);
};

3
src/libstore/include/nix/store/build/drv-output-substitution-goal.hh
View file

@ -39,8 +39,7 @@ public:
GoalState state;
Co init();
Co
realisationFetched(Goals waitees, std::shared_ptr<const UnkeyedRealisation> outputInfo, nix::ref<nix::Store> sub);
Co realisationFetched(Goals waitees, std::shared_ptr<const Realisation> outputInfo, nix::ref<nix::Store> sub);
void timedOut(Error && ex) override
{

12
src/libstore/include/nix/store/dummy-store-impl.hh
View file

@ -30,18 +30,6 @@ struct DummyStore : virtual Store
*/
boost::concurrent_flat_map<StorePath, PathInfoAndContents> contents;
/**
* The build trace maps the pair of a content-addressing (fixed or
* floating) derivations an one of its output to a
* (content-addressed) store object.
*
* It is [curried](https://en.wikipedia.org/wiki/Currying), so we
* instead having a single output with a `DrvOutput` key, we have an
* outer map for the derivation, and inner maps for the outputs of a
* given derivation.
*/
boost::concurrent_flat_map<Hash, std::map<std::string, ref<UnkeyedRealisation>>> buildTrace;
DummyStore(ref<const Config> config)
: Store{*config}
, config(config)

2
src/libstore/include/nix/store/dummy-store.hh
View file

@ -3,8 +3,6 @@
#include "nix/store/store-api.hh"
#include <boost/unordered/concurrent_flat_map.hpp>
namespace nix {
struct DummyStore;

4
src/libstore/include/nix/store/legacy-ssh-store.hh
View file

@ -208,8 +208,8 @@ public:
*/
std::optional<TrustedFlag> isTrustedClient() override;
void queryRealisationUncached(
const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override
void
queryRealisationUncached(const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept override
// TODO: Implement
{
unsupported("queryRealisation");

2
src/libstore/include/nix/store/local-overlay-store.hh
View file

@ -173,7 +173,7 @@ private:
* Check lower store if upper DB does not have.
*/
void queryRealisationUncached(
const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override;
const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
/**
* Call `remountIfNecessary` after collecting garbage normally.

6
src/libstore/include/nix/store/local-store.hh
View file

@ -385,10 +385,10 @@ public:
void cacheDrvOutputMapping(
State & state, const uint64_t deriver, const std::string & outputName, const StorePath & output);
std::optional<const UnkeyedRealisation> queryRealisation_(State & state, const DrvOutput & id);
std::optional<std::pair<int64_t, UnkeyedRealisation>> queryRealisationCore_(State & state, const DrvOutput & id);
std::optional<const Realisation> queryRealisation_(State & state, const DrvOutput & id);
std::optional<std::pair<int64_t, Realisation>> queryRealisationCore_(State & state, const DrvOutput & id);
void queryRealisationUncached(
const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override;
const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
std::optional<std::string> getVersion() override;

50
src/libstore/include/nix/store/realisation.hh
View file

@ -46,12 +46,12 @@ struct DrvOutput
static DrvOutput parse(const std::string &);
bool operator==(const DrvOutput &) const = default;
auto operator<=>(const DrvOutput &) const = default;
GENERATE_CMP(DrvOutput, me->drvHash, me->outputName);
};
struct UnkeyedRealisation
struct Realisation
{
DrvOutput id;
StorePath outPath;
StringSet signatures;
@ -64,35 +64,22 @@ struct UnkeyedRealisation
*/
std::map<DrvOutput, StorePath> dependentRealisations;
std::string fingerprint(const DrvOutput & key) const;
std::string fingerprint() const;
void sign(const Signer &);
bool checkSignature(const PublicKeys & publicKeys, const std::string & sig) const;
size_t checkSignatures(const PublicKeys & publicKeys) const;
void sign(const DrvOutput & key, const Signer &);
static std::set<Realisation> closure(Store &, const std::set<Realisation> &);
static void closure(Store &, const std::set<Realisation> &, std::set<Realisation> & res);
bool checkSignature(const DrvOutput & key, const PublicKeys & publicKeys, const std::string & sig) const;
bool isCompatibleWith(const Realisation & other) const;
size_t checkSignatures(const DrvOutput & key, const PublicKeys & publicKeys) const;
const StorePath & getPath() const
StorePath getPath() const
{
return outPath;
}
// TODO sketchy that it avoids signatures
GENERATE_CMP(UnkeyedRealisation, me->outPath);
};
struct Realisation : UnkeyedRealisation
{
DrvOutput id;
bool isCompatibleWith(const UnkeyedRealisation & other) const;
static std::set<Realisation> closure(Store &, const std::set<Realisation> &);
static void closure(Store &, const std::set<Realisation> &, std::set<Realisation> & res);
bool operator==(const Realisation &) const = default;
auto operator<=>(const Realisation &) const = default;
GENERATE_CMP(Realisation, me->id, me->outPath);
};
/**
@ -116,13 +103,12 @@ struct OpaquePath
{
StorePath path;
const StorePath & getPath() const
StorePath getPath() const
{
return path;
}
bool operator==(const OpaquePath &) const = default;
auto operator<=>(const OpaquePath &) const = default;
GENERATE_CMP(OpaquePath, me->path);
};
/**
@ -130,7 +116,7 @@ struct OpaquePath
*/
struct RealisedPath
{
/**
/*
* A path is either the result of the realisation of a derivation or
* an opaque blob that has been directly added to the store
*/
@ -152,14 +138,13 @@ struct RealisedPath
/**
* Get the raw store path associated to this
*/
const StorePath & path() const;
StorePath path() const;
void closure(Store & store, Set & ret) const;
static void closure(Store & store, const Set & startPaths, Set & ret);
Set closure(Store & store) const;
bool operator==(const RealisedPath &) const = default;
auto operator<=>(const RealisedPath &) const = default;
GENERATE_CMP(RealisedPath, me->raw);
};
class MissingRealisation : public Error
@ -182,5 +167,4 @@ public:
} // namespace nix
JSON_IMPL(nix::UnkeyedRealisation)
JSON_IMPL(nix::Realisation)

2
src/libstore/include/nix/store/remote-store.hh
View file

@ -102,7 +102,7 @@ struct RemoteStore : public virtual Store, public virtual GcStore, public virtua
void registerDrvOutput(const Realisation & info) override;
void queryRealisationUncached(
const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override;
const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
void
buildPaths(const std::vector<DerivedPath> & paths, BuildMode buildMode, std::shared_ptr<Store> evalStore) override;

9
src/libstore/include/nix/store/store-api.hh
View file

@ -31,7 +31,6 @@ MakeError(SubstituterDisabled, Error);
MakeError(InvalidStoreReference, Error);
struct UnkeyedRealisation;
struct Realisation;
struct RealisedPath;
struct DrvOutput;
@ -399,12 +398,12 @@ public:
/**
* Query the information about a realisation.
*/
std::shared_ptr<const UnkeyedRealisation> queryRealisation(const DrvOutput &);
std::shared_ptr<const Realisation> queryRealisation(const DrvOutput &);
/**
* Asynchronous version of queryRealisation().
*/
void queryRealisation(const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept;
void queryRealisation(const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept;
/**
* Check whether the given valid path info is sufficiently attested, by
@ -431,8 +430,8 @@ protected:
virtual void
queryPathInfoUncached(const StorePath & path, Callback<std::shared_ptr<const ValidPathInfo>> callback) noexcept = 0;
virtual void queryRealisationUncached(
const DrvOutput &, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept = 0;
virtual void
queryRealisationUncached(const DrvOutput &, Callback<std::shared_ptr<const Realisation>> callback) noexcept = 0;
public:

8
src/libstore/local-overlay-store.cc
View file

@ -77,7 +77,7 @@ void LocalOverlayStore::registerDrvOutput(const Realisation & info)
// First do queryRealisation on lower layer to populate DB
auto res = lowerStore->queryRealisation(info.id);
if (res)
LocalStore::registerDrvOutput({*res, info.id});
LocalStore::registerDrvOutput(*res);
LocalStore::registerDrvOutput(info);
}
@ -108,12 +108,12 @@ void LocalOverlayStore::queryPathInfoUncached(
}
void LocalOverlayStore::queryRealisationUncached(
const DrvOutput & drvOutput, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept
const DrvOutput & drvOutput, Callback<std::shared_ptr<const Realisation>> callback) noexcept
{
auto callbackPtr = std::make_shared<decltype(callback)>(std::move(callback));
LocalStore::queryRealisationUncached(
drvOutput, {[this, drvOutput, callbackPtr](std::future<std::shared_ptr<const UnkeyedRealisation>> fut) {
drvOutput, {[this, drvOutput, callbackPtr](std::future<std::shared_ptr<const Realisation>> fut) {
try {
auto info = fut.get();
if (info)
@ -123,7 +123,7 @@ void LocalOverlayStore::queryRealisationUncached(
}
// If we don't have it, check lower store
lowerStore->queryRealisation(
drvOutput, {[callbackPtr](std::future<std::shared_ptr<const UnkeyedRealisation>> fut) {
drvOutput, {[callbackPtr](std::future<std::shared_ptr<const Realisation>> fut) {
try {
(*callbackPtr)(fut.get());
} catch (...) {

17
src/libstore/local-store.cc
View file

@ -1036,7 +1036,7 @@ bool LocalStore::pathInfoIsUntrusted(const ValidPathInfo & info)
bool LocalStore::realisationIsUntrusted(const Realisation & realisation)
{
return config->requireSigs && !realisation.checkSignatures(realisation.id, getPublicKeys());
return config->requireSigs && !realisation.checkSignatures(getPublicKeys());
}
void LocalStore::addToStore(const ValidPathInfo & info, Source & source, RepairFlag repair, CheckSigsFlag checkSigs)
@ -1586,7 +1586,7 @@ void LocalStore::addSignatures(const StorePath & storePath, const StringSet & si
});
}
std::optional<std::pair<int64_t, UnkeyedRealisation>>
std::optional<std::pair<int64_t, Realisation>>
LocalStore::queryRealisationCore_(LocalStore::State & state, const DrvOutput & id)
{
auto useQueryRealisedOutput(state.stmts->QueryRealisedOutput.use()(id.strHash())(id.outputName));
@ -1598,13 +1598,14 @@ LocalStore::queryRealisationCore_(LocalStore::State & state, const DrvOutput & i
return {
{realisationDbId,
UnkeyedRealisation{
Realisation{
.id = id,
.outPath = outputPath,
.signatures = signatures,
}}};
}
std::optional<const UnkeyedRealisation> LocalStore::queryRealisation_(LocalStore::State & state, const DrvOutput & id)
std::optional<const Realisation> LocalStore::queryRealisation_(LocalStore::State & state, const DrvOutput & id)
{
auto maybeCore = queryRealisationCore_(state, id);
if (!maybeCore)
@ -1630,13 +1631,13 @@ std::optional<const UnkeyedRealisation> LocalStore::queryRealisation_(LocalStore
}
void LocalStore::queryRealisationUncached(
const DrvOutput & id, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept
const DrvOutput & id, Callback<std::shared_ptr<const Realisation>> callback) noexcept
{
try {
auto maybeRealisation = retrySQLite<std::optional<const UnkeyedRealisation>>(
[&]() { return queryRealisation_(*_state->lock(), id); });
auto maybeRealisation =
retrySQLite<std::optional<const Realisation>>([&]() { return queryRealisation_(*_state->lock(), id); });
if (maybeRealisation)
callback(std::make_shared<const UnkeyedRealisation>(maybeRealisation.value()));
callback(std::make_shared<const Realisation>(maybeRealisation.value()));
else
callback(nullptr);

5
src/libstore/misc.cc
View file

@ -360,12 +360,11 @@ drvOutputReferences(Store & store, const Derivation & drv, const StorePath & out
if (!outputHash)
throw Error(
"output '%s' of derivation '%s' isn't realised", outputName, store.printStorePath(inputDrv));
DrvOutput key{*outputHash, outputName};
auto thisRealisation = store.queryRealisation(key);
auto thisRealisation = store.queryRealisation(DrvOutput{*outputHash, outputName});
if (!thisRealisation)
throw Error(
"output '%s' of derivation '%s' isn’t built", outputName, store.printStorePath(inputDrv));
inputRealisations.insert({*thisRealisation, std::move(key)});
inputRealisations.insert(*thisRealisation);
}
}
if (!inputNode.value.empty()) {

50
src/libstore/realisation.cc
View file

@ -39,7 +39,7 @@ void Realisation::closure(Store & store, const std::set<Realisation> & startOutp
std::set<Realisation> res;
for (auto & [currentDep, _] : current.dependentRealisations) {
if (auto currentRealisation = store.queryRealisation(currentDep))
res.insert({*currentRealisation, currentDep});
res.insert(*currentRealisation);
else
throw Error("Unrealised derivation '%s'", currentDep.to_string());
}
@ -61,25 +61,24 @@ void Realisation::closure(Store & store, const std::set<Realisation> & startOutp
});
}
std::string UnkeyedRealisation::fingerprint(const DrvOutput & key) const
std::string Realisation::fingerprint() const
{
nlohmann::json serialized = Realisation{*this, key};
nlohmann::json serialized = *this;
serialized.erase("signatures");
return serialized.dump();
}
void UnkeyedRealisation::sign(const DrvOutput & key, const Signer & signer)
void Realisation::sign(const Signer & signer)
{
signatures.insert(signer.signDetached(fingerprint(key)));
signatures.insert(signer.signDetached(fingerprint()));
}
bool UnkeyedRealisation::checkSignature(
const DrvOutput & key, const PublicKeys & publicKeys, const std::string & sig) const
bool Realisation::checkSignature(const PublicKeys & publicKeys, const std::string & sig) const
{
return verifyDetached(fingerprint(key), sig, publicKeys);
return verifyDetached(fingerprint(), sig, publicKeys);
}
size_t UnkeyedRealisation::checkSignatures(const DrvOutput & key, const PublicKeys & publicKeys) const
size_t Realisation::checkSignatures(const PublicKeys & publicKeys) const
{
// FIXME: Maybe we should return `maxSigs` if the realisation corresponds to
// an input-addressed one − because in that case the drv is enough to check
@ -87,18 +86,19 @@ size_t UnkeyedRealisation::checkSignatures(const DrvOutput & key, const PublicKe
size_t good = 0;
for (auto & sig : signatures)
if (checkSignature(key, publicKeys, sig))
if (checkSignature(publicKeys, sig))
good++;
return good;
}
const StorePath & RealisedPath::path() const
StorePath RealisedPath::path() const
{
return std::visit([](auto && arg) -> auto & { return arg.getPath(); }, raw);
return std::visit([](auto && arg) { return arg.getPath(); }, raw);
}
bool Realisation::isCompatibleWith(const UnkeyedRealisation & other) const
bool Realisation::isCompatibleWith(const Realisation & other) const
{
assert(id == other.id);
if (outPath == other.outPath) {
if (dependentRealisations.empty() != other.dependentRealisations.empty()) {
warn(
@ -144,7 +144,7 @@ namespace nlohmann {
using namespace nix;
UnkeyedRealisation adl_serializer<UnkeyedRealisation>::from_json(const json & json0)
Realisation adl_serializer<Realisation>::from_json(const json & json0)
{
auto json = getObject(json0);
@ -157,39 +157,25 @@ UnkeyedRealisation adl_serializer<UnkeyedRealisation>::from_json(const json & js
for (auto & [jsonDepId, jsonDepOutPath] : getObject(*jsonDependencies))
dependentRealisations.insert({DrvOutput::parse(jsonDepId), jsonDepOutPath});
return UnkeyedRealisation{
return Realisation{
.id = DrvOutput::parse(valueAt(json, "id")),
.outPath = valueAt(json, "outPath"),
.signatures = signatures,
.dependentRealisations = dependentRealisations,
};
}
void adl_serializer<UnkeyedRealisation>::to_json(json & json, const UnkeyedRealisation & r)
void adl_serializer<Realisation>::to_json(json & json, const Realisation & r)
{
auto jsonDependentRealisations = nlohmann::json::object();
for (auto & [depId, depOutPath] : r.dependentRealisations)
jsonDependentRealisations.emplace(depId.to_string(), depOutPath);
json = {
{"id", r.id.to_string()},
{"outPath", r.outPath},
{"signatures", r.signatures},
{"dependentRealisations", jsonDependentRealisations},
};
}
Realisation adl_serializer<Realisation>::from_json(const json & json0)
{
auto json = getObject(json0);
return Realisation{
static_cast<UnkeyedRealisation>(json0),
DrvOutput::parse(valueAt(json, "id")),
};
}
void adl_serializer<Realisation>::to_json(json & json, const Realisation & r)
{
json = static_cast<const UnkeyedRealisation &>(r);
json["id"] = r.id.to_string();
}
} // namespace nlohmann

18
src/libstore/remote-store.cc
View file

@ -501,7 +501,7 @@ void RemoteStore::registerDrvOutput(const Realisation & info)
}
void RemoteStore::queryRealisationUncached(
const DrvOutput & id, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept
const DrvOutput & id, Callback<std::shared_ptr<const Realisation>> callback) noexcept
{
try {
auto conn(getConnection());
@ -515,21 +515,21 @@ void RemoteStore::queryRealisationUncached(
conn->to << id.to_string();
conn.processStderr();
auto real = [&]() -> std::shared_ptr<const UnkeyedRealisation> {
auto real = [&]() -> std::shared_ptr<const Realisation> {
if (GET_PROTOCOL_MINOR(conn->protoVersion) < 31) {
auto outPaths = WorkerProto::Serialise<std::set<StorePath>>::read(*this, *conn);
if (outPaths.empty())
return nullptr;
return std::make_shared<const UnkeyedRealisation>(UnkeyedRealisation{.outPath = *outPaths.begin()});
return std::make_shared<const Realisation>(Realisation{.id = id, .outPath = *outPaths.begin()});
} else {
auto realisations = WorkerProto::Serialise<std::set<Realisation>>::read(*this, *conn);
if (realisations.empty())
return nullptr;
return std::make_shared<const UnkeyedRealisation>(*realisations.begin());
return std::make_shared<const Realisation>(*realisations.begin());
}
}();
callback(std::shared_ptr<const UnkeyedRealisation>(real));
callback(std::shared_ptr<const Realisation>(real));
} catch (...) {
return callback.rethrow();
}
@ -626,15 +626,13 @@ std::vector<KeyedBuildResult> RemoteStore::buildPathsWithResults(
auto realisation = queryRealisation(outputId);
if (!realisation)
throw MissingRealisation(outputId);
success.builtOutputs.emplace(output, Realisation{*realisation, outputId});
success.builtOutputs.emplace(output, *realisation);
} else {
success.builtOutputs.emplace(
output,
Realisation{
UnkeyedRealisation{
.outPath = outputPath,
},
outputId,
.id = outputId,
.outPath = outputPath,
});
}
}

4
src/libstore/restricted-store.cc
View file

@ -107,7 +107,7 @@ struct RestrictedStore : public virtual IndirectRootStore, public virtual GcStor
void registerDrvOutput(const Realisation & info) override;
void queryRealisationUncached(
const DrvOutput & id, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept override;
const DrvOutput & id, Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
void
buildPaths(const std::vector<DerivedPath> & paths, BuildMode buildMode, std::shared_ptr<Store> evalStore) override;
@ -244,7 +244,7 @@ void RestrictedStore::registerDrvOutput(const Realisation & info)
}
void RestrictedStore::queryRealisationUncached(
const DrvOutput & id, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept
const DrvOutput & id, Callback<std::shared_ptr<const Realisation>> callback) noexcept
// XXX: This should probably be allowed if the realisation corresponds to
// an allowed derivation
{

20
src/libstore/store-api.cc
View file

@ -598,8 +598,7 @@ void Store::queryPathInfo(const StorePath & storePath, Callback<ref<const ValidP
}});
}
void Store::queryRealisation(
const DrvOutput & id, Callback<std::shared_ptr<const UnkeyedRealisation>> callback) noexcept
void Store::queryRealisation(const DrvOutput & id, Callback<std::shared_ptr<const Realisation>> callback) noexcept
{
try {
@ -625,20 +624,20 @@ void Store::queryRealisation(
auto callbackPtr = std::make_shared<decltype(callback)>(std::move(callback));
queryRealisationUncached(id, {[this, id, callbackPtr](std::future<std::shared_ptr<const UnkeyedRealisation>> fut) {
queryRealisationUncached(id, {[this, id, callbackPtr](std::future<std::shared_ptr<const Realisation>> fut) {
try {
auto info = fut.get();
if (diskCache) {
if (info)
diskCache->upsertRealisation(
config.getReference().render(/*FIXME withParams=*/false), {*info, id});
config.getReference().render(/*FIXME withParams=*/false), *info);
else
diskCache->upsertAbsentRealisation(
config.getReference().render(/*FIXME withParams=*/false), id);
}
(*callbackPtr)(std::shared_ptr<const UnkeyedRealisation>(info));
(*callbackPtr)(std::shared_ptr<const Realisation>(info));
} catch (...) {
callbackPtr->rethrow();
@ -646,9 +645,9 @@ void Store::queryRealisation(
}});
}
std::shared_ptr<const UnkeyedRealisation> Store::queryRealisation(const DrvOutput & id)
std::shared_ptr<const Realisation> Store::queryRealisation(const DrvOutput & id)
{
using RealPtr = std::shared_ptr<const UnkeyedRealisation>;
using RealPtr = std::shared_ptr<const Realisation>;
std::promise<RealPtr> promise;
queryRealisation(id, {[&](std::future<RealPtr> result) {
@ -911,12 +910,11 @@ std::map<StorePath, StorePath> copyPaths(
std::set<Realisation> toplevelRealisations;
for (auto & path : paths) {
storePaths.insert(path.path());
if (auto * realisation = std::get_if<Realisation>(&path.raw)) {
if (auto realisation = std::get_if<Realisation>(&path.raw)) {
experimentalFeatureSettings.require(Xp::CaDerivations);
toplevelRealisations.insert(*realisation);
}
}
auto pathsMap = copyPaths(srcStore, dstStore, storePaths, repair, checkSigs, substitute);
try {
@ -933,7 +931,7 @@ std::map<StorePath, StorePath> copyPaths(
"dependency of '%s' but isn't registered",
drvOutput.to_string(),
current.id.to_string());
children.insert({*currentChild, drvOutput});
children.insert(*currentChild);
}
return children;
},
@ -1201,7 +1199,7 @@ void Store::signRealisation(Realisation & realisation)
for (auto & secretKeyFile : secretKeyFiles.get()) {
SecretKey secretKey(readFile(secretKeyFile));
LocalSigner signer(std::move(secretKey));
realisation.sign(realisation.id, signer);
realisation.sign(signer);
}
}

7
src/libstore/unix/build/derivation-builder.cc
View file

@ -1830,12 +1830,7 @@ SingleDrvOutputs DerivationBuilderImpl::registerOutputs()
for (auto & [outputName, newInfo] : infos) {
auto oldinfo = get(initialOutputs, outputName);
assert(oldinfo);
auto thisRealisation = Realisation{
{
.outPath = newInfo.path,
},
DrvOutput{oldinfo->outputHash, outputName},
};
auto thisRealisation = Realisation{.id = DrvOutput{oldinfo->outputHash, outputName}, .outPath = newInfo.path};
if (experimentalFeatureSettings.isEnabled(Xp::CaDerivations) && !drv.type().isImpure()) {
store.signRealisation(thisRealisation);
store.registerDrvOutput(thisRealisation);

19
src/libutil/include/nix/util/hash.hh
View file

@ -222,22 +222,3 @@ public:
};
} // namespace nix
template<>
struct std::hash<nix::Hash>
{
std::size_t operator()(const nix::Hash & hash) const noexcept
{
assert(hash.hashSize > sizeof(size_t));
return *reinterpret_cast<const std::size_t *>(&hash.hash);
}
};
namespace nix {
inline std::size_t hash_value(const Hash & hash)
{
return std::hash<Hash>{}(hash);
}
} // namespace nix