forked from lix-project/lix
d2162e7acd
As discussed in #7417, it would be good to make more string values work as installables. That is to say, if an installable refers to a value, and the value is a string, it used to not work at all, since #7484, it works somewhat, and this PR make it work some more. The new cases that are added for `BuiltPath` contexts: - Fixed input- or content-addressed derivation: ``` nix-repl> hello.out.outPath "/nix/store/jppfl2bp1zhx8sgs2mgifmsx6dv16mv2-hello-2.12" nix-repl> :p builtins.getContext hello.out.outPath { "/nix/store/c7jrxqjhdda93lhbkanqfs07x2bzazbm-hello-2.12.drv" = { outputs = [ "out" ]; }; } The string matches the specified single output of that derivation, so it should also be valid. - Floating content-addressed derivation: ``` nix-repl> (hello.overrideAttrs (_: { __contentAddressed = true; })).out.outPath "/1a08j26xqc0zm8agps8anxpjji410yvsx4pcgyn4bfan1ddkx2g0" nix-repl> :p builtins.getContext (hello.overrideAttrs (_: { __contentAddressed = true; })).out.outPath { "/nix/store/qc645pyf9wl37c6qvqzaqkwsm1gp48al-hello-2.12.drv" = { outputs = [ "out" ]; }; } ``` The string is not a path but a placeholder, however it also matches the context, and because it is a CA derivation we have no better option. This should also be valid. We may also want to think about richer attrset based values (also discussed in that issue and #6507), but this change "completes" our string-based building blocks, from which the others can be desugared into or at least described/document/taught in terms of. Progress towards #7417 Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
223 lines
6.6 KiB
C++
223 lines
6.6 KiB
C++
#include "globals.hh"
|
|
#include "installable-flake.hh"
|
|
#include "installable-derived-path.hh"
|
|
#include "outputs-spec.hh"
|
|
#include "util.hh"
|
|
#include "command.hh"
|
|
#include "attr-path.hh"
|
|
#include "common-eval-args.hh"
|
|
#include "derivations.hh"
|
|
#include "eval-inline.hh"
|
|
#include "eval.hh"
|
|
#include "get-drvs.hh"
|
|
#include "store-api.hh"
|
|
#include "shared.hh"
|
|
#include "flake/flake.hh"
|
|
#include "eval-cache.hh"
|
|
#include "url.hh"
|
|
#include "registry.hh"
|
|
#include "build-result.hh"
|
|
|
|
#include <regex>
|
|
#include <queue>
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
namespace nix {
|
|
|
|
std::vector<std::string> InstallableFlake::getActualAttrPaths()
|
|
{
|
|
std::vector<std::string> res;
|
|
|
|
for (auto & prefix : prefixes)
|
|
res.push_back(prefix + *attrPaths.begin());
|
|
|
|
for (auto & s : attrPaths)
|
|
res.push_back(s);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value * InstallableFlake::getFlakeOutputs(EvalState & state, const flake::LockedFlake & lockedFlake)
|
|
{
|
|
auto vFlake = state.allocValue();
|
|
|
|
callFlake(state, lockedFlake, *vFlake);
|
|
|
|
auto aOutputs = vFlake->attrs->get(state.symbols.create("outputs"));
|
|
assert(aOutputs);
|
|
|
|
state.forceValue(*aOutputs->value, [&]() { return aOutputs->value->determinePos(noPos); });
|
|
|
|
return aOutputs->value;
|
|
}
|
|
|
|
static std::string showAttrPaths(const std::vector<std::string> & paths)
|
|
{
|
|
std::string s;
|
|
for (const auto & [n, i] : enumerate(paths)) {
|
|
if (n > 0) s += n + 1 == paths.size() ? " or " : ", ";
|
|
s += '\''; s += i; s += '\'';
|
|
}
|
|
return s;
|
|
}
|
|
|
|
InstallableFlake::InstallableFlake(
|
|
SourceExprCommand * cmd,
|
|
ref<EvalState> state,
|
|
FlakeRef && flakeRef,
|
|
std::string_view fragment,
|
|
ExtendedOutputsSpec extendedOutputsSpec,
|
|
Strings attrPaths,
|
|
Strings prefixes,
|
|
const flake::LockFlags & lockFlags)
|
|
: InstallableValue(state),
|
|
flakeRef(flakeRef),
|
|
attrPaths(fragment == "" ? attrPaths : Strings{(std::string) fragment}),
|
|
prefixes(fragment == "" ? Strings{} : prefixes),
|
|
extendedOutputsSpec(std::move(extendedOutputsSpec)),
|
|
lockFlags(lockFlags)
|
|
{
|
|
if (cmd && cmd->getAutoArgs(*state)->size())
|
|
throw UsageError("'--arg' and '--argstr' are incompatible with flakes");
|
|
}
|
|
|
|
DerivedPathsWithInfo InstallableFlake::toDerivedPaths()
|
|
{
|
|
Activity act(*logger, lvlTalkative, actUnknown, fmt("evaluating derivation '%s'", what()));
|
|
|
|
auto attr = getCursor(*state);
|
|
|
|
auto attrPath = attr->getAttrPathStr();
|
|
|
|
if (!attr->isDerivation()) {
|
|
|
|
// FIXME: use eval cache?
|
|
auto v = attr->forceValue();
|
|
|
|
if (std::optional derivedPathWithInfo = trySinglePathToDerivedPaths(
|
|
v,
|
|
noPos,
|
|
fmt("while evaluating the flake output attribute '%s'", attrPath)))
|
|
{
|
|
return { *derivedPathWithInfo };
|
|
}
|
|
else
|
|
throw Error("flake output attribute '%s' is not a derivation or path", attrPath);
|
|
}
|
|
|
|
auto drvPath = attr->forceDerivation();
|
|
|
|
std::optional<NixInt> priority;
|
|
|
|
if (attr->maybeGetAttr(state->sOutputSpecified)) {
|
|
} else if (auto aMeta = attr->maybeGetAttr(state->sMeta)) {
|
|
if (auto aPriority = aMeta->maybeGetAttr("priority"))
|
|
priority = aPriority->getInt();
|
|
}
|
|
|
|
return {{
|
|
.path = DerivedPath::Built {
|
|
.drvPath = std::move(drvPath),
|
|
.outputs = std::visit(overloaded {
|
|
[&](const ExtendedOutputsSpec::Default & d) -> OutputsSpec {
|
|
std::set<std::string> outputsToInstall;
|
|
if (auto aOutputSpecified = attr->maybeGetAttr(state->sOutputSpecified)) {
|
|
if (aOutputSpecified->getBool()) {
|
|
if (auto aOutputName = attr->maybeGetAttr("outputName"))
|
|
outputsToInstall = { aOutputName->getString() };
|
|
}
|
|
} else if (auto aMeta = attr->maybeGetAttr(state->sMeta)) {
|
|
if (auto aOutputsToInstall = aMeta->maybeGetAttr("outputsToInstall"))
|
|
for (auto & s : aOutputsToInstall->getListOfStrings())
|
|
outputsToInstall.insert(s);
|
|
}
|
|
|
|
if (outputsToInstall.empty())
|
|
outputsToInstall.insert("out");
|
|
|
|
return OutputsSpec::Names { std::move(outputsToInstall) };
|
|
},
|
|
[&](const ExtendedOutputsSpec::Explicit & e) -> OutputsSpec {
|
|
return e;
|
|
},
|
|
}, extendedOutputsSpec.raw()),
|
|
},
|
|
.info = make_ref<ExtraPathInfoFlake>(
|
|
ExtraPathInfoValue::Value {
|
|
.priority = priority,
|
|
.attrPath = attrPath,
|
|
.extendedOutputsSpec = extendedOutputsSpec,
|
|
},
|
|
ExtraPathInfoFlake::Flake {
|
|
.originalRef = flakeRef,
|
|
.resolvedRef = getLockedFlake()->flake.lockedRef,
|
|
}),
|
|
}};
|
|
}
|
|
|
|
std::pair<Value *, PosIdx> InstallableFlake::toValue(EvalState & state)
|
|
{
|
|
return {&getCursor(state)->forceValue(), noPos};
|
|
}
|
|
|
|
std::vector<ref<eval_cache::AttrCursor>>
|
|
InstallableFlake::getCursors(EvalState & state)
|
|
{
|
|
auto evalCache = openEvalCache(state, getLockedFlake());
|
|
|
|
auto root = evalCache->getRoot();
|
|
|
|
std::vector<ref<eval_cache::AttrCursor>> res;
|
|
|
|
Suggestions suggestions;
|
|
auto attrPaths = getActualAttrPaths();
|
|
|
|
for (auto & attrPath : attrPaths) {
|
|
debug("trying flake output attribute '%s'", attrPath);
|
|
|
|
auto attr = root->findAlongAttrPath(parseAttrPath(state, attrPath));
|
|
if (attr) {
|
|
res.push_back(ref(*attr));
|
|
} else {
|
|
suggestions += attr.getSuggestions();
|
|
}
|
|
}
|
|
|
|
if (res.size() == 0)
|
|
throw Error(
|
|
suggestions,
|
|
"flake '%s' does not provide attribute %s",
|
|
flakeRef,
|
|
showAttrPaths(attrPaths));
|
|
|
|
return res;
|
|
}
|
|
|
|
std::shared_ptr<flake::LockedFlake> InstallableFlake::getLockedFlake() const
|
|
{
|
|
if (!_lockedFlake) {
|
|
flake::LockFlags lockFlagsApplyConfig = lockFlags;
|
|
// FIXME why this side effect?
|
|
lockFlagsApplyConfig.applyNixConfig = true;
|
|
_lockedFlake = std::make_shared<flake::LockedFlake>(lockFlake(*state, flakeRef, lockFlagsApplyConfig));
|
|
}
|
|
return _lockedFlake;
|
|
}
|
|
|
|
FlakeRef InstallableFlake::nixpkgsFlakeRef() const
|
|
{
|
|
auto lockedFlake = getLockedFlake();
|
|
|
|
if (auto nixpkgsInput = lockedFlake->lockFile.findInput({"nixpkgs"})) {
|
|
if (auto lockedNode = std::dynamic_pointer_cast<const flake::LockedNode>(nixpkgsInput)) {
|
|
debug("using nixpkgs flake '%s'", lockedNode->lockedRef);
|
|
return std::move(lockedNode->lockedRef);
|
|
}
|
|
}
|
|
|
|
return defaultNixpkgsFlakeRef();
|
|
}
|
|
|
|
}
|