forked from lix-project/lix
60b7121d2c
We want to be able to write down `foo.drv^bar.drv^baz`:
`foo.drv^bar.drv` is the dynamic derivation (since it is itself a
derivation output, `bar.drv` from `foo.drv`).
To that end, we create `Single{Derivation,BuiltPath}` types, that are
very similar except instead of having multiple outputs (in a set or
map), they have a single one. This is for everything to the left of the
rightmost `^`.
`NixStringContextElem` has an analogous change, and now can reuse
`SingleDerivedPath` at the top level. In fact, if we ever get rid of
`DrvDeep`, `NixStringContextElem` could be replaced with
`SingleDerivedPath` entirely!
Important note: some JSON formats have changed.
We already can *produce* dynamic derivations, but we can't refer to them
directly. Today, we can merely express building or example at the top
imperatively over time by building `foo.drv^bar.drv`, and then with a
second nix invocation doing `<result-from-first>^baz`, but this is not
declarative. The ethos of Nix of being able to write down the full plan
everything you want to do, and then execute than plan with a single
command, and for that we need the new inductive form of these types.
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
Co-authored-by: Valentin Gagarin <valentin.gagarin@tweag.io>
66 lines
2.1 KiB
C++
66 lines
2.1 KiB
C++
#include "installable-derived-path.hh"
|
|
#include "derivations.hh"
|
|
|
|
namespace nix {
|
|
|
|
std::string InstallableDerivedPath::what() const
|
|
{
|
|
return derivedPath.to_string(*store);
|
|
}
|
|
|
|
DerivedPathsWithInfo InstallableDerivedPath::toDerivedPaths()
|
|
{
|
|
return {{
|
|
.path = derivedPath,
|
|
.info = make_ref<ExtraPathInfo>(),
|
|
}};
|
|
}
|
|
|
|
std::optional<StorePath> InstallableDerivedPath::getStorePath()
|
|
{
|
|
return derivedPath.getBaseStorePath();
|
|
}
|
|
|
|
InstallableDerivedPath InstallableDerivedPath::parse(
|
|
ref<Store> store,
|
|
std::string_view prefix,
|
|
ExtendedOutputsSpec extendedOutputsSpec)
|
|
{
|
|
auto derivedPath = std::visit(overloaded {
|
|
// If the user did not use ^, we treat the output more
|
|
// liberally: we accept a symlink chain or an actual
|
|
// store path.
|
|
[&](const ExtendedOutputsSpec::Default &) -> DerivedPath {
|
|
auto storePath = store->followLinksToStorePath(prefix);
|
|
// Remove this prior to stabilizing the new CLI.
|
|
if (storePath.isDerivation()) {
|
|
auto oldDerivedPath = DerivedPath::Built {
|
|
.drvPath = makeConstantStorePathRef(storePath),
|
|
.outputs = OutputsSpec::All { },
|
|
};
|
|
warn(
|
|
"The interpretation of store paths arguments ending in `.drv` recently changed. If this command is now failing try again with '%s'",
|
|
oldDerivedPath.to_string(*store));
|
|
};
|
|
return DerivedPath::Opaque {
|
|
.path = std::move(storePath),
|
|
};
|
|
},
|
|
// If the user did use ^, we just do exactly what is written.
|
|
[&](const ExtendedOutputsSpec::Explicit & outputSpec) -> DerivedPath {
|
|
auto drv = make_ref<SingleDerivedPath>(SingleDerivedPath::parse(*store, prefix));
|
|
drvRequireExperiment(*drv);
|
|
return DerivedPath::Built {
|
|
.drvPath = std::move(drv),
|
|
.outputs = outputSpec,
|
|
};
|
|
},
|
|
}, extendedOutputsSpec.raw());
|
|
return InstallableDerivedPath {
|
|
store,
|
|
std::move(derivedPath),
|
|
};
|
|
}
|
|
|
|
}
|