mirror of
https://github.com/NixOS/nix.git
synced 2025-12-11 03:21:03 +01:00
76bd600302
This is an example of "Parse, don't validate" principle [1]. Before, we had a number of `StringSet`s in `DerivationOptions` that were not *actually* allowed to be arbitrary sets of strings. Instead, each set member had to be one of: - a store path - a CA "downstream placeholder" - an output name Only later, in the code that checks outputs, would these strings be further parsed to match these cases. (Actually, only 2 by that point, because the placeholders must be rewritten away by then.) Now, we fully parse everything up front, and have an "honest" data type that reflects these invariants: - store paths are parsed, stored as (opaque) deriving paths - CA "downstream placeholders" are rewritten to the output deriving paths they denote - output names are the only arbitrary strings left Since the first two cases both become deriving paths, that leaves us with a `std::variant<SingleDerivedPath, String>` data type, which we use in our sets instead. Getting rid of placeholders is especially nice because we are replacing them with something much more internally-structured / transparent. [1]: https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/ Co-authored-by: Sergei Zimmerman <sergei@zimmerman.foo> Co-authored-by: Eelco Dolstra <edolstra@gmail.com>
683 lines
29 KiB
C++
683 lines
29 KiB
C++
#include "nix/store/derivation-options.hh"
|
|
#include "nix/util/json-utils.hh"
|
|
#include "nix/store/parsed-derivations.hh"
|
|
#include "nix/store/derivations.hh"
|
|
#include "nix/store/derived-path.hh"
|
|
#include "nix/store/store-api.hh"
|
|
#include "nix/util/types.hh"
|
|
#include "nix/util/util.hh"
|
|
#include "nix/store/globals.hh"
|
|
#include "nix/util/variant-wrapper.hh"
|
|
|
|
#include <optional>
|
|
#include <string>
|
|
#include <variant>
|
|
#include <regex>
|
|
#include <ranges>
|
|
|
|
namespace nix {
|
|
|
|
static std::optional<std::string>
|
|
getStringAttr(const StringMap & env, const StructuredAttrs * parsed, const std::string & name)
|
|
{
|
|
if (parsed) {
|
|
auto i = parsed->structuredAttrs.find(name);
|
|
if (i == parsed->structuredAttrs.end())
|
|
return {};
|
|
else {
|
|
if (!i->second.is_string())
|
|
throw Error("attribute '%s' of must be a string", name);
|
|
return i->second.get<std::string>();
|
|
}
|
|
} else {
|
|
auto i = env.find(name);
|
|
if (i == env.end())
|
|
return {};
|
|
else
|
|
return i->second;
|
|
}
|
|
}
|
|
|
|
static bool getBoolAttr(const StringMap & env, const StructuredAttrs * parsed, const std::string & name, bool def)
|
|
{
|
|
if (parsed) {
|
|
auto i = parsed->structuredAttrs.find(name);
|
|
if (i == parsed->structuredAttrs.end())
|
|
return def;
|
|
else {
|
|
if (!i->second.is_boolean())
|
|
throw Error("attribute '%s' must be a Boolean", name);
|
|
return i->second.get<bool>();
|
|
}
|
|
} else {
|
|
auto i = env.find(name);
|
|
if (i == env.end())
|
|
return def;
|
|
else
|
|
return i->second == "1";
|
|
}
|
|
}
|
|
|
|
static std::optional<Strings>
|
|
getStringsAttr(const StringMap & env, const StructuredAttrs * parsed, const std::string & name)
|
|
{
|
|
if (parsed) {
|
|
auto i = parsed->structuredAttrs.find(name);
|
|
if (i == parsed->structuredAttrs.end())
|
|
return {};
|
|
else {
|
|
if (!i->second.is_array())
|
|
throw Error("attribute '%s' must be a list of strings", name);
|
|
auto & a = getArray(i->second);
|
|
Strings res;
|
|
for (auto j = a.begin(); j != a.end(); ++j) {
|
|
if (!j->is_string())
|
|
throw Error("attribute '%s' must be a list of strings", name);
|
|
res.push_back(j->get<std::string>());
|
|
}
|
|
return res;
|
|
}
|
|
} else {
|
|
auto i = env.find(name);
|
|
if (i == env.end())
|
|
return {};
|
|
else
|
|
return tokenizeString<Strings>(i->second);
|
|
}
|
|
}
|
|
|
|
static std::optional<StringSet>
|
|
getStringSetAttr(const StringMap & env, const StructuredAttrs * parsed, const std::string & name)
|
|
{
|
|
auto ss = getStringsAttr(env, parsed, name);
|
|
return ss ? (std::optional{StringSet{ss->begin(), ss->end()}}) : (std::optional<StringSet>{});
|
|
}
|
|
|
|
template<typename Inputs>
|
|
using OutputChecks = DerivationOptions<Inputs>::OutputChecks;
|
|
|
|
template<typename Inputs>
|
|
using OutputChecksVariant = std::variant<OutputChecks<Inputs>, std::map<std::string, OutputChecks<Inputs>>>;
|
|
|
|
DerivationOptions<StorePath> derivationOptionsFromStructuredAttrs(
|
|
const StoreDirConfig & store,
|
|
const StringMap & env,
|
|
const StructuredAttrs * parsed,
|
|
bool shouldWarn,
|
|
const ExperimentalFeatureSettings & mockXpSettings)
|
|
{
|
|
/* Use the SingleDerivedPath version with empty inputDrvs, then
|
|
resolve. */
|
|
DerivedPathMap<StringSet> emptyInputDrvs{};
|
|
auto singleDerivedPathOptions =
|
|
derivationOptionsFromStructuredAttrs(store, emptyInputDrvs, env, parsed, shouldWarn, mockXpSettings);
|
|
|
|
/* "Resolve" all SingleDerivedPath inputs to StorePath. */
|
|
auto resolved = tryResolve(
|
|
singleDerivedPathOptions,
|
|
[&](ref<const SingleDerivedPath> drvPath, const std::string & outputName) -> std::optional<StorePath> {
|
|
// there should be nothing to resolve
|
|
assert(false);
|
|
});
|
|
|
|
/* Since we should never need to call the call back, there should be
|
|
no way it fails. */
|
|
assert(resolved);
|
|
|
|
return *resolved;
|
|
}
|
|
|
|
static void flatten(const nlohmann::json & value, StringSet & res)
|
|
{
|
|
if (value.is_array())
|
|
for (auto & v : value)
|
|
flatten(v, res);
|
|
else if (value.is_string())
|
|
res.insert(value);
|
|
else
|
|
throw Error("'exportReferencesGraph' value is not an array or a string");
|
|
}
|
|
|
|
DerivationOptions<SingleDerivedPath> derivationOptionsFromStructuredAttrs(
|
|
const StoreDirConfig & store,
|
|
const DerivedPathMap<StringSet> & inputDrvs,
|
|
const StringMap & env,
|
|
const StructuredAttrs * parsed,
|
|
bool shouldWarn,
|
|
const ExperimentalFeatureSettings & mockXpSettings)
|
|
{
|
|
DerivationOptions<SingleDerivedPath> defaults = {};
|
|
|
|
std::map<std::string, SingleDerivedPath::Built> placeholders;
|
|
if (mockXpSettings.isEnabled(Xp::CaDerivations)) {
|
|
/* Initialize placeholder map from inputDrvs */
|
|
auto initPlaceholders = [&](this const auto & initPlaceholders,
|
|
ref<const SingleDerivedPath> basePath,
|
|
const DerivedPathMap<StringSet>::ChildNode & node) -> void {
|
|
for (const auto & outputName : node.value) {
|
|
auto built = SingleDerivedPath::Built{
|
|
.drvPath = basePath,
|
|
.output = outputName,
|
|
};
|
|
placeholders.insert_or_assign(
|
|
DownstreamPlaceholder::fromSingleDerivedPathBuilt(built, mockXpSettings).render(),
|
|
std::move(built));
|
|
}
|
|
|
|
for (const auto & [outputName, childNode] : node.childMap) {
|
|
initPlaceholders(
|
|
make_ref<const SingleDerivedPath>(SingleDerivedPath::Built{
|
|
.drvPath = basePath,
|
|
.output = outputName,
|
|
}),
|
|
childNode);
|
|
}
|
|
};
|
|
|
|
for (const auto & [drvPath, outputs] : inputDrvs.map) {
|
|
auto basePath = make_ref<const SingleDerivedPath>(SingleDerivedPath::Opaque{drvPath});
|
|
initPlaceholders(basePath, outputs);
|
|
}
|
|
}
|
|
|
|
auto parseSingleDerivedPath = [&](const std::string & pathS) -> SingleDerivedPath {
|
|
if (auto it = placeholders.find(pathS); it != placeholders.end())
|
|
return it->second;
|
|
else
|
|
return SingleDerivedPath::Opaque{store.toStorePath(pathS).first};
|
|
};
|
|
|
|
auto parseRef = [&](const std::string & pathS) -> DrvRef<SingleDerivedPath> {
|
|
if (auto it = placeholders.find(pathS); it != placeholders.end())
|
|
return it->second;
|
|
if (store.isStorePath(pathS))
|
|
return SingleDerivedPath::Opaque{store.toStorePath(pathS).first};
|
|
else
|
|
return pathS;
|
|
};
|
|
|
|
if (shouldWarn && parsed) {
|
|
auto & structuredAttrs = parsed->structuredAttrs;
|
|
|
|
if (get(structuredAttrs, "allowedReferences")) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'allowedReferences'; use 'outputChecks' instead");
|
|
}
|
|
if (get(structuredAttrs, "allowedRequisites")) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'allowedRequisites'; use 'outputChecks' instead");
|
|
}
|
|
if (get(structuredAttrs, "disallowedRequisites")) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'disallowedRequisites'; use 'outputChecks' instead");
|
|
}
|
|
if (get(structuredAttrs, "disallowedReferences")) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'disallowedReferences'; use 'outputChecks' instead");
|
|
}
|
|
if (get(structuredAttrs, "maxSize")) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'maxSize'; use 'outputChecks' instead");
|
|
}
|
|
if (get(structuredAttrs, "maxClosureSize")) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'maxClosureSize'; use 'outputChecks' instead");
|
|
}
|
|
}
|
|
|
|
return {
|
|
.outputChecks = [&]() -> OutputChecksVariant<SingleDerivedPath> {
|
|
if (parsed) {
|
|
auto & structuredAttrs = parsed->structuredAttrs;
|
|
|
|
std::map<std::string, OutputChecks<SingleDerivedPath>> res;
|
|
if (auto * outputChecks = get(structuredAttrs, "outputChecks")) {
|
|
for (auto & [outputName, output_] : getObject(*outputChecks)) {
|
|
OutputChecks<SingleDerivedPath> checks;
|
|
|
|
auto & output = getObject(output_);
|
|
|
|
if (auto maxSize = get(output, "maxSize"))
|
|
checks.maxSize = maxSize->get<uint64_t>();
|
|
|
|
if (auto maxClosureSize = get(output, "maxClosureSize"))
|
|
checks.maxClosureSize = maxClosureSize->get<uint64_t>();
|
|
|
|
auto get_ =
|
|
[&](const std::string & name) -> std::optional<std::set<DrvRef<SingleDerivedPath>>> {
|
|
if (auto i = get(output, name)) {
|
|
std::set<DrvRef<SingleDerivedPath>> res;
|
|
for (auto j = i->begin(); j != i->end(); ++j) {
|
|
if (!j->is_string())
|
|
throw Error("attribute '%s' must be a list of strings", name);
|
|
res.insert(parseRef(j->get<std::string>()));
|
|
}
|
|
return res;
|
|
}
|
|
return {};
|
|
};
|
|
|
|
res.insert_or_assign(
|
|
outputName,
|
|
OutputChecks<SingleDerivedPath>{
|
|
.maxSize = [&]() -> std::optional<uint64_t> {
|
|
if (auto maxSize = get(output, "maxSize"))
|
|
return maxSize->get<uint64_t>();
|
|
else
|
|
return std::nullopt;
|
|
}(),
|
|
.maxClosureSize = [&]() -> std::optional<uint64_t> {
|
|
if (auto maxClosureSize = get(output, "maxClosureSize"))
|
|
return maxClosureSize->get<uint64_t>();
|
|
else
|
|
return std::nullopt;
|
|
}(),
|
|
.allowedReferences = get_("allowedReferences"),
|
|
.disallowedReferences =
|
|
get_("disallowedReferences").value_or(std::set<DrvRef<SingleDerivedPath>>{}),
|
|
.allowedRequisites = get_("allowedRequisites"),
|
|
.disallowedRequisites =
|
|
get_("disallowedRequisites").value_or(std::set<DrvRef<SingleDerivedPath>>{}),
|
|
});
|
|
}
|
|
}
|
|
return res;
|
|
} else {
|
|
auto parseRefSet = [&](const std::optional<StringSet> optionalStringSet)
|
|
-> std::optional<std::set<DrvRef<SingleDerivedPath>>> {
|
|
if (!optionalStringSet)
|
|
return std::nullopt;
|
|
auto range = *optionalStringSet | std::views::transform(parseRef);
|
|
return std::set<DrvRef<SingleDerivedPath>>(range.begin(), range.end());
|
|
};
|
|
return OutputChecks<SingleDerivedPath>{
|
|
// legacy non-structured-attributes case
|
|
.ignoreSelfRefs = true,
|
|
.allowedReferences = parseRefSet(getStringSetAttr(env, parsed, "allowedReferences")),
|
|
.disallowedReferences = parseRefSet(getStringSetAttr(env, parsed, "disallowedReferences"))
|
|
.value_or(std::set<DrvRef<SingleDerivedPath>>{}),
|
|
.allowedRequisites = parseRefSet(getStringSetAttr(env, parsed, "allowedRequisites")),
|
|
.disallowedRequisites = parseRefSet(getStringSetAttr(env, parsed, "disallowedRequisites"))
|
|
.value_or(std::set<DrvRef<SingleDerivedPath>>{}),
|
|
};
|
|
}
|
|
}(),
|
|
.unsafeDiscardReferences =
|
|
[&] {
|
|
std::map<std::string, bool> res;
|
|
|
|
if (parsed) {
|
|
auto & structuredAttrs = parsed->structuredAttrs;
|
|
|
|
if (auto * udr = get(structuredAttrs, "unsafeDiscardReferences")) {
|
|
for (auto & [outputName, output] : getObject(*udr)) {
|
|
if (!output.is_boolean())
|
|
throw Error("attribute 'unsafeDiscardReferences.\"%s\"' must be a Boolean", outputName);
|
|
res.insert_or_assign(outputName, output.get<bool>());
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}(),
|
|
.passAsFile =
|
|
[&] {
|
|
StringSet res;
|
|
if (auto * passAsFileString = get(env, "passAsFile")) {
|
|
if (parsed) {
|
|
if (shouldWarn) {
|
|
warn(
|
|
"'structuredAttrs' disables the effect of the top-level attribute 'passAsFile'; because all JSON is always passed via file");
|
|
}
|
|
} else {
|
|
res = tokenizeString<StringSet>(*passAsFileString);
|
|
}
|
|
}
|
|
return res;
|
|
}(),
|
|
.exportReferencesGraph =
|
|
[&] {
|
|
std::map<std::string, std::set<SingleDerivedPath>> ret;
|
|
|
|
if (parsed) {
|
|
auto * e = optionalValueAt(parsed->structuredAttrs, "exportReferencesGraph");
|
|
if (!e || !e->is_object())
|
|
return ret;
|
|
for (auto & [key, storePathsJson] : getObject(*e)) {
|
|
StringSet ss;
|
|
flatten(storePathsJson, ss);
|
|
std::set<SingleDerivedPath> storePaths;
|
|
for (auto & s : ss)
|
|
storePaths.insert(parseSingleDerivedPath(s));
|
|
ret.insert_or_assign(key, std::move(storePaths));
|
|
}
|
|
} else {
|
|
auto s = getOr(env, "exportReferencesGraph", "");
|
|
Strings ss = tokenizeString<Strings>(s);
|
|
if (ss.size() % 2 != 0)
|
|
throw Error("odd number of tokens in 'exportReferencesGraph': '%1%'", s);
|
|
for (Strings::iterator i = ss.begin(); i != ss.end();) {
|
|
auto fileName = std::move(*i++);
|
|
static std::regex regex("[A-Za-z_][A-Za-z0-9_.-]*");
|
|
if (!std::regex_match(fileName, regex))
|
|
throw Error("invalid file name '%s' in 'exportReferencesGraph'", fileName);
|
|
|
|
auto & storePathS = *i++;
|
|
ret.insert_or_assign(std::move(fileName), std::set{parseSingleDerivedPath(storePathS)});
|
|
}
|
|
}
|
|
return ret;
|
|
}(),
|
|
.additionalSandboxProfile =
|
|
getStringAttr(env, parsed, "__sandboxProfile").value_or(defaults.additionalSandboxProfile),
|
|
.noChroot = getBoolAttr(env, parsed, "__noChroot", defaults.noChroot),
|
|
.impureHostDeps = getStringSetAttr(env, parsed, "__impureHostDeps").value_or(defaults.impureHostDeps),
|
|
.impureEnvVars = getStringSetAttr(env, parsed, "impureEnvVars").value_or(defaults.impureEnvVars),
|
|
.allowLocalNetworking = getBoolAttr(env, parsed, "__darwinAllowLocalNetworking", defaults.allowLocalNetworking),
|
|
.requiredSystemFeatures =
|
|
getStringSetAttr(env, parsed, "requiredSystemFeatures").value_or(defaults.requiredSystemFeatures),
|
|
.preferLocalBuild = getBoolAttr(env, parsed, "preferLocalBuild", defaults.preferLocalBuild),
|
|
.allowSubstitutes = getBoolAttr(env, parsed, "allowSubstitutes", defaults.allowSubstitutes),
|
|
};
|
|
}
|
|
|
|
template<typename Input>
|
|
StringSet DerivationOptions<Input>::getRequiredSystemFeatures(const BasicDerivation & drv) const
|
|
{
|
|
// FIXME: cache this?
|
|
StringSet res;
|
|
for (auto & i : requiredSystemFeatures)
|
|
res.insert(i);
|
|
if (!drv.type().hasKnownOutputPaths())
|
|
res.insert("ca-derivations");
|
|
return res;
|
|
}
|
|
|
|
template<typename Input>
|
|
bool DerivationOptions<Input>::canBuildLocally(Store & localStore, const BasicDerivation & drv) const
|
|
{
|
|
if (drv.platform != settings.thisSystem.get() && !settings.extraPlatforms.get().count(drv.platform)
|
|
&& !drv.isBuiltin())
|
|
return false;
|
|
|
|
if (settings.maxBuildJobs.get() == 0 && !drv.isBuiltin())
|
|
return false;
|
|
|
|
for (auto & feature : getRequiredSystemFeatures(drv))
|
|
if (!localStore.config.systemFeatures.get().count(feature))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
template<typename Input>
|
|
bool DerivationOptions<Input>::willBuildLocally(Store & localStore, const BasicDerivation & drv) const
|
|
{
|
|
return preferLocalBuild && canBuildLocally(localStore, drv);
|
|
}
|
|
|
|
template<typename Input>
|
|
bool DerivationOptions<Input>::substitutesAllowed() const
|
|
{
|
|
return settings.alwaysAllowSubstitutes ? true : allowSubstitutes;
|
|
}
|
|
|
|
template<typename Input>
|
|
bool DerivationOptions<Input>::useUidRange(const BasicDerivation & drv) const
|
|
{
|
|
return getRequiredSystemFeatures(drv).count("uid-range");
|
|
}
|
|
|
|
std::optional<DerivationOptions<StorePath>> tryResolve(
|
|
const DerivationOptions<SingleDerivedPath> & drvOptions,
|
|
std::function<std::optional<StorePath>(ref<const SingleDerivedPath> drvPath, const std::string & outputName)>
|
|
queryResolutionChain)
|
|
{
|
|
auto tryResolvePath = [&](const SingleDerivedPath & input) -> std::optional<StorePath> {
|
|
return std::visit(
|
|
overloaded{
|
|
[](const SingleDerivedPath::Opaque & p) -> std::optional<StorePath> { return p.path; },
|
|
[&](const SingleDerivedPath::Built & p) -> std::optional<StorePath> {
|
|
return queryResolutionChain(p.drvPath, p.output);
|
|
}},
|
|
input.raw());
|
|
};
|
|
|
|
auto tryResolveRef = [&](const DrvRef<SingleDerivedPath> & ref) -> std::optional<DrvRef<StorePath>> {
|
|
return std::visit(
|
|
overloaded{
|
|
[](const OutputName & outputName) -> std::optional<DrvRef<StorePath>> { return outputName; },
|
|
[&](const SingleDerivedPath & input) -> std::optional<DrvRef<StorePath>> {
|
|
return tryResolvePath(input);
|
|
}},
|
|
ref);
|
|
};
|
|
|
|
auto tryResolveRefSet =
|
|
[&](const std::set<DrvRef<SingleDerivedPath>> & refSet) -> std::optional<std::set<DrvRef<StorePath>>> {
|
|
std::set<DrvRef<StorePath>> resolvedSet;
|
|
for (const auto & ref : refSet) {
|
|
auto resolvedRef = tryResolveRef(ref);
|
|
if (!resolvedRef)
|
|
return std::nullopt;
|
|
resolvedSet.insert(*resolvedRef);
|
|
}
|
|
return resolvedSet;
|
|
};
|
|
|
|
// Helper function to try resolving OutputChecks using functional style
|
|
auto tryResolveOutputChecks = [&](const DerivationOptions<SingleDerivedPath>::OutputChecks & checks)
|
|
-> std::optional<DerivationOptions<StorePath>::OutputChecks> {
|
|
std::optional<std::set<DrvRef<StorePath>>> resolvedAllowedReferences;
|
|
if (checks.allowedReferences) {
|
|
resolvedAllowedReferences = tryResolveRefSet(*checks.allowedReferences);
|
|
if (!resolvedAllowedReferences)
|
|
return std::nullopt;
|
|
}
|
|
|
|
std::optional<std::set<DrvRef<StorePath>>> resolvedAllowedRequisites;
|
|
if (checks.allowedRequisites) {
|
|
resolvedAllowedRequisites = tryResolveRefSet(*checks.allowedRequisites);
|
|
if (!resolvedAllowedRequisites)
|
|
return std::nullopt;
|
|
}
|
|
|
|
auto resolvedDisallowedReferences = tryResolveRefSet(checks.disallowedReferences);
|
|
if (!resolvedDisallowedReferences)
|
|
return std::nullopt;
|
|
|
|
auto resolvedDisallowedRequisites = tryResolveRefSet(checks.disallowedRequisites);
|
|
if (!resolvedDisallowedRequisites)
|
|
return std::nullopt;
|
|
|
|
return DerivationOptions<StorePath>::OutputChecks{
|
|
.ignoreSelfRefs = checks.ignoreSelfRefs,
|
|
.maxSize = checks.maxSize,
|
|
.maxClosureSize = checks.maxClosureSize,
|
|
.allowedReferences = resolvedAllowedReferences,
|
|
.disallowedReferences = *resolvedDisallowedReferences,
|
|
.allowedRequisites = resolvedAllowedRequisites,
|
|
.disallowedRequisites = *resolvedDisallowedRequisites,
|
|
};
|
|
};
|
|
|
|
// Helper function to resolve exportReferencesGraph using functional style
|
|
auto tryResolveExportReferencesGraph = [&](const std::map<std::string, std::set<SingleDerivedPath>> & exportGraph)
|
|
-> std::optional<std::map<std::string, std::set<StorePath>>> {
|
|
std::map<std::string, std::set<StorePath>> resolved;
|
|
for (const auto & [name, inputPaths] : exportGraph) {
|
|
std::set<StorePath> resolvedPaths;
|
|
for (const auto & inputPath : inputPaths) {
|
|
auto resolvedPath = tryResolvePath(inputPath);
|
|
if (!resolvedPath)
|
|
return std::nullopt;
|
|
resolvedPaths.insert(*resolvedPath);
|
|
}
|
|
resolved.emplace(name, std::move(resolvedPaths));
|
|
}
|
|
return resolved;
|
|
};
|
|
|
|
// Resolve outputChecks using functional style with std::visit
|
|
auto resolvedOutputChecks = std::visit(
|
|
overloaded{
|
|
[&](const DerivationOptions<SingleDerivedPath>::OutputChecks & checks)
|
|
-> std::optional<std::variant<
|
|
DerivationOptions<StorePath>::OutputChecks,
|
|
std::map<std::string, DerivationOptions<StorePath>::OutputChecks>>> {
|
|
auto resolved = tryResolveOutputChecks(checks);
|
|
if (!resolved)
|
|
return std::nullopt;
|
|
return std::variant<
|
|
DerivationOptions<StorePath>::OutputChecks,
|
|
std::map<std::string, DerivationOptions<StorePath>::OutputChecks>>(*resolved);
|
|
},
|
|
[&](const std::map<std::string, DerivationOptions<SingleDerivedPath>::OutputChecks> & checksMap)
|
|
-> std::optional<std::variant<
|
|
DerivationOptions<StorePath>::OutputChecks,
|
|
std::map<std::string, DerivationOptions<StorePath>::OutputChecks>>> {
|
|
std::map<std::string, DerivationOptions<StorePath>::OutputChecks> resolvedMap;
|
|
for (const auto & [outputName, checks] : checksMap) {
|
|
auto resolved = tryResolveOutputChecks(checks);
|
|
if (!resolved)
|
|
return std::nullopt;
|
|
resolvedMap.emplace(outputName, *resolved);
|
|
}
|
|
return std::variant<
|
|
DerivationOptions<StorePath>::OutputChecks,
|
|
std::map<std::string, DerivationOptions<StorePath>::OutputChecks>>(resolvedMap);
|
|
}},
|
|
drvOptions.outputChecks);
|
|
|
|
if (!resolvedOutputChecks)
|
|
return std::nullopt;
|
|
|
|
// Resolve exportReferencesGraph
|
|
auto resolvedExportGraph = tryResolveExportReferencesGraph(drvOptions.exportReferencesGraph);
|
|
if (!resolvedExportGraph)
|
|
return std::nullopt;
|
|
|
|
// Return resolved DerivationOptions using designated initializers
|
|
return DerivationOptions<StorePath>{
|
|
.outputChecks = *resolvedOutputChecks,
|
|
.unsafeDiscardReferences = drvOptions.unsafeDiscardReferences,
|
|
.passAsFile = drvOptions.passAsFile,
|
|
.exportReferencesGraph = *resolvedExportGraph,
|
|
.additionalSandboxProfile = drvOptions.additionalSandboxProfile,
|
|
.noChroot = drvOptions.noChroot,
|
|
.impureHostDeps = drvOptions.impureHostDeps,
|
|
.impureEnvVars = drvOptions.impureEnvVars,
|
|
.allowLocalNetworking = drvOptions.allowLocalNetworking,
|
|
.requiredSystemFeatures = drvOptions.requiredSystemFeatures,
|
|
.preferLocalBuild = drvOptions.preferLocalBuild,
|
|
.allowSubstitutes = drvOptions.allowSubstitutes,
|
|
};
|
|
}
|
|
|
|
template struct DerivationOptions<StorePath>;
|
|
template struct DerivationOptions<SingleDerivedPath>;
|
|
|
|
} // namespace nix
|
|
|
|
namespace nlohmann {
|
|
|
|
using namespace nix;
|
|
|
|
DerivationOptions<SingleDerivedPath> adl_serializer<DerivationOptions<SingleDerivedPath>>::from_json(const json & json_)
|
|
{
|
|
auto & json = getObject(json_);
|
|
|
|
return {
|
|
.outputChecks = [&]() -> OutputChecksVariant<SingleDerivedPath> {
|
|
auto outputChecks = getObject(valueAt(json, "outputChecks"));
|
|
|
|
auto forAllOutputsOpt = optionalValueAt(outputChecks, "forAllOutputs");
|
|
auto perOutputOpt = optionalValueAt(outputChecks, "perOutput");
|
|
|
|
if (forAllOutputsOpt && !perOutputOpt) {
|
|
return static_cast<OutputChecks<SingleDerivedPath>>(*forAllOutputsOpt);
|
|
} else if (perOutputOpt && !forAllOutputsOpt) {
|
|
return static_cast<std::map<std::string, OutputChecks<SingleDerivedPath>>>(*perOutputOpt);
|
|
} else {
|
|
throw Error("Exactly one of 'perOutput' or 'forAllOutputs' is required");
|
|
}
|
|
}(),
|
|
|
|
.unsafeDiscardReferences = valueAt(json, "unsafeDiscardReferences"),
|
|
.passAsFile = getStringSet(valueAt(json, "passAsFile")),
|
|
.exportReferencesGraph = valueAt(json, "exportReferencesGraph"),
|
|
|
|
.additionalSandboxProfile = getString(valueAt(json, "additionalSandboxProfile")),
|
|
.noChroot = getBoolean(valueAt(json, "noChroot")),
|
|
.impureHostDeps = getStringSet(valueAt(json, "impureHostDeps")),
|
|
.impureEnvVars = getStringSet(valueAt(json, "impureEnvVars")),
|
|
.allowLocalNetworking = getBoolean(valueAt(json, "allowLocalNetworking")),
|
|
|
|
.requiredSystemFeatures = getStringSet(valueAt(json, "requiredSystemFeatures")),
|
|
.preferLocalBuild = getBoolean(valueAt(json, "preferLocalBuild")),
|
|
.allowSubstitutes = getBoolean(valueAt(json, "allowSubstitutes")),
|
|
};
|
|
}
|
|
|
|
void adl_serializer<DerivationOptions<SingleDerivedPath>>::to_json(
|
|
json & json, const DerivationOptions<SingleDerivedPath> & o)
|
|
{
|
|
json["outputChecks"] = std::visit(
|
|
overloaded{
|
|
[&](const OutputChecks<SingleDerivedPath> & checks) {
|
|
nlohmann::json outputChecks;
|
|
outputChecks["forAllOutputs"] = checks;
|
|
return outputChecks;
|
|
},
|
|
[&](const std::map<std::string, OutputChecks<SingleDerivedPath>> & checksPerOutput) {
|
|
nlohmann::json outputChecks;
|
|
outputChecks["perOutput"] = checksPerOutput;
|
|
return outputChecks;
|
|
},
|
|
},
|
|
o.outputChecks);
|
|
|
|
json["unsafeDiscardReferences"] = o.unsafeDiscardReferences;
|
|
json["passAsFile"] = o.passAsFile;
|
|
json["exportReferencesGraph"] = o.exportReferencesGraph;
|
|
|
|
json["additionalSandboxProfile"] = o.additionalSandboxProfile;
|
|
json["noChroot"] = o.noChroot;
|
|
json["impureHostDeps"] = o.impureHostDeps;
|
|
json["impureEnvVars"] = o.impureEnvVars;
|
|
json["allowLocalNetworking"] = o.allowLocalNetworking;
|
|
|
|
json["requiredSystemFeatures"] = o.requiredSystemFeatures;
|
|
json["preferLocalBuild"] = o.preferLocalBuild;
|
|
json["allowSubstitutes"] = o.allowSubstitutes;
|
|
}
|
|
|
|
OutputChecks<SingleDerivedPath> adl_serializer<OutputChecks<SingleDerivedPath>>::from_json(const json & json_)
|
|
{
|
|
auto & json = getObject(json_);
|
|
|
|
return {
|
|
.ignoreSelfRefs = getBoolean(valueAt(json, "ignoreSelfRefs")),
|
|
.maxSize = ptrToOwned<uint64_t>(getNullable(valueAt(json, "maxSize"))),
|
|
.maxClosureSize = ptrToOwned<uint64_t>(getNullable(valueAt(json, "maxClosureSize"))),
|
|
.allowedReferences =
|
|
ptrToOwned<std::set<DrvRef<SingleDerivedPath>>>(getNullable(valueAt(json, "allowedReferences"))),
|
|
.disallowedReferences = valueAt(json, "disallowedReferences"),
|
|
.allowedRequisites =
|
|
ptrToOwned<std::set<DrvRef<SingleDerivedPath>>>(getNullable(valueAt(json, "allowedRequisites"))),
|
|
.disallowedRequisites = valueAt(json, "disallowedRequisites"),
|
|
};
|
|
}
|
|
|
|
void adl_serializer<OutputChecks<SingleDerivedPath>>::to_json(json & json, const OutputChecks<SingleDerivedPath> & c)
|
|
{
|
|
json["ignoreSelfRefs"] = c.ignoreSelfRefs;
|
|
json["maxSize"] = c.maxSize;
|
|
json["maxClosureSize"] = c.maxClosureSize;
|
|
json["allowedReferences"] = c.allowedReferences;
|
|
json["disallowedReferences"] = c.disallowedReferences;
|
|
json["allowedRequisites"] = c.allowedRequisites;
|
|
json["disallowedRequisites"] = c.disallowedRequisites;
|
|
}
|
|
|
|
} // namespace nlohmann
|