diff --git a/src/libstore-tests/derivation-advanced-attrs.cc b/src/libstore-tests/derivation-advanced-attrs.cc index 1b146c60ea3..3f34a824ff6 100644 --- a/src/libstore-tests/derivation-advanced-attrs.cc +++ b/src/libstore-tests/derivation-advanced-attrs.cc @@ -81,10 +81,11 @@ TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes_defaults) auto drvPath = writeDerivation(*store, got, NoRepair, true); - ParsedDerivation parsedDrv(got.env); - DerivationOptions options = DerivationOptions::fromParsedDerivation(*store, parsedDrv); + auto parsedDrv = StructuredAttrs::tryParse(got.env); + DerivationOptions options = + DerivationOptions::fromStructuredAttrs(*store, got.env, parsedDrv ? &*parsedDrv : nullptr); - EXPECT_TRUE(!parsedDrv.hasStructuredAttrs()); + EXPECT_TRUE(!parsedDrv); EXPECT_EQ(options.additionalSandboxProfile, ""); EXPECT_EQ(options.noChroot, false); @@ -116,12 +117,13 @@ TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes) auto drvPath = writeDerivation(*store, got, NoRepair, true); - ParsedDerivation parsedDrv(got.env); - DerivationOptions options = DerivationOptions::fromParsedDerivation(*store, parsedDrv); + auto parsedDrv = StructuredAttrs::tryParse(got.env); + DerivationOptions options = + DerivationOptions::fromStructuredAttrs(*store, got.env, parsedDrv ? &*parsedDrv : nullptr); StringSet systemFeatures{"rainbow", "uid-range"}; - EXPECT_TRUE(!parsedDrv.hasStructuredAttrs()); + EXPECT_TRUE(!parsedDrv); EXPECT_EQ(options.additionalSandboxProfile, "sandcastle"); EXPECT_EQ(options.noChroot, true); @@ -157,10 +159,11 @@ TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes_structuredAttr auto drvPath = writeDerivation(*store, got, NoRepair, true); - ParsedDerivation parsedDrv(got.env); - DerivationOptions options = DerivationOptions::fromParsedDerivation(*store, parsedDrv); + auto parsedDrv = StructuredAttrs::tryParse(got.env); + DerivationOptions options = + DerivationOptions::fromStructuredAttrs(*store, got.env, parsedDrv ? &*parsedDrv : nullptr); - EXPECT_TRUE(parsedDrv.hasStructuredAttrs()); + EXPECT_TRUE(parsedDrv); EXPECT_EQ(options.additionalSandboxProfile, ""); EXPECT_EQ(options.noChroot, false); @@ -191,12 +194,13 @@ TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes_structuredAttr auto drvPath = writeDerivation(*store, got, NoRepair, true); - ParsedDerivation parsedDrv(got.env); - DerivationOptions options = DerivationOptions::fromParsedDerivation(*store, parsedDrv); + auto parsedDrv = StructuredAttrs::tryParse(got.env); + DerivationOptions options = + DerivationOptions::fromStructuredAttrs(*store, got.env, parsedDrv ? &*parsedDrv : nullptr); StringSet systemFeatures{"rainbow", "uid-range"}; - EXPECT_TRUE(parsedDrv.hasStructuredAttrs()); + EXPECT_TRUE(parsedDrv); EXPECT_EQ(options.additionalSandboxProfile, "sandcastle"); EXPECT_EQ(options.noChroot, true); diff --git a/src/libstore/build/derivation-goal.cc b/src/libstore/build/derivation-goal.cc index 0978a37d36f..e2db3d8197a 100644 --- a/src/libstore/build/derivation-goal.cc +++ b/src/libstore/build/derivation-goal.cc @@ -194,10 +194,12 @@ Goal::Co DerivationGoal::haveDerivation() { trace("have derivation"); - parsedDrv = std::make_unique(drv->env); + if (auto parsedOpt = StructuredAttrs::tryParse(drv->env)) { + parsedDrv = std::make_unique(*parsedOpt); + } try { drvOptions = std::make_unique( - DerivationOptions::fromParsedDerivation(worker.store, *parsedDrv)); + DerivationOptions::fromStructuredAttrs(worker.store, drv->env, parsedDrv.get())); } catch (Error & e) { e.addTrace({}, "while parsing derivation '%s'", worker.store.printStorePath(drvPath)); throw; diff --git a/src/libstore/build/derivation-goal.hh b/src/libstore/build/derivation-goal.hh index b23eab94c70..8258c19e9b7 100644 --- a/src/libstore/build/derivation-goal.hh +++ b/src/libstore/build/derivation-goal.hh @@ -2,6 +2,7 @@ ///@file #include "parsed-derivations.hh" +#include "derivations.hh" #include "derivation-options.hh" #ifndef _WIN32 # include "user-lock.hh" @@ -143,7 +144,7 @@ struct DerivationGoal : public Goal */ std::unique_ptr drv; - std::unique_ptr parsedDrv; + std::unique_ptr parsedDrv; std::unique_ptr drvOptions; /** diff --git a/src/libstore/derivation-options.cc b/src/libstore/derivation-options.cc index 7db5897a46f..4cf6a009791 100644 --- a/src/libstore/derivation-options.cc +++ b/src/libstore/derivation-options.cc @@ -1,6 +1,8 @@ #include "derivation-options.hh" #include "json-utils.hh" #include "parsed-derivations.hh" +#include "derivations.hh" +#include "store-api.hh" #include "types.hh" #include "util.hh" @@ -11,39 +13,112 @@ namespace nix { +static std::optional +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->is_string()) + throw Error("attribute '%s' of must be a string", name); + return i->get(); + } + } 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->is_boolean()) + throw Error("attribute '%s' must be a Boolean", name); + return i->get(); + } + } else { + auto i = env.find(name); + if (i == env.end()) + return def; + else + return i->second == "1"; + } +} + +static std::optional +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->is_array()) + throw Error("attribute '%s' must be a list of strings", name); + Strings 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.push_back(j->get()); + } + return res; + } + } else { + auto i = env.find(name); + if (i == env.end()) + return {}; + else + return tokenizeString(i->second); + } +} + +static std::optional +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{}); +} + using OutputChecks = DerivationOptions::OutputChecks; using OutputChecksVariant = std::variant>; -DerivationOptions -DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const ParsedDerivation & parsed, bool shouldWarn) +DerivationOptions DerivationOptions::fromStructuredAttrs( + const StoreDirConfig & store, const StringMap & env, const StructuredAttrs * parsed, bool shouldWarn) { DerivationOptions defaults = {}; - auto structuredAttrs = parsed.structuredAttrs.get(); - - if (shouldWarn && structuredAttrs) { - if (get(*structuredAttrs, "allowedReferences")) { + if (shouldWarn && parsed) { + if (get(parsed->structuredAttrs, "allowedReferences")) { warn( "'structuredAttrs' disables the effect of the top-level attribute 'allowedReferences'; use 'outputChecks' instead"); } - if (get(*structuredAttrs, "allowedRequisites")) { + if (get(parsed->structuredAttrs, "allowedRequisites")) { warn( "'structuredAttrs' disables the effect of the top-level attribute 'allowedRequisites'; use 'outputChecks' instead"); } - if (get(*structuredAttrs, "disallowedRequisites")) { + if (get(parsed->structuredAttrs, "disallowedRequisites")) { warn( "'structuredAttrs' disables the effect of the top-level attribute 'disallowedRequisites'; use 'outputChecks' instead"); } - if (get(*structuredAttrs, "disallowedReferences")) { + if (get(parsed->structuredAttrs, "disallowedReferences")) { warn( "'structuredAttrs' disables the effect of the top-level attribute 'disallowedReferences'; use 'outputChecks' instead"); } - if (get(*structuredAttrs, "maxSize")) { + if (get(parsed->structuredAttrs, "maxSize")) { warn( "'structuredAttrs' disables the effect of the top-level attribute 'maxSize'; use 'outputChecks' instead"); } - if (get(*structuredAttrs, "maxClosureSize")) { + if (get(parsed->structuredAttrs, "maxClosureSize")) { warn( "'structuredAttrs' disables the effect of the top-level attribute 'maxClosureSize'; use 'outputChecks' instead"); } @@ -51,9 +126,9 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars return { .outputChecks = [&]() -> OutputChecksVariant { - if (auto structuredAttrs = parsed.structuredAttrs.get()) { + if (parsed) { std::map res; - if (auto outputChecks = get(*structuredAttrs, "outputChecks")) { + if (auto outputChecks = get(parsed->structuredAttrs, "outputChecks")) { for (auto & [outputName, output] : getObject(*outputChecks)) { OutputChecks checks; @@ -91,10 +166,10 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars return OutputChecks{ // legacy non-structured-attributes case .ignoreSelfRefs = true, - .allowedReferences = parsed.getStringSetAttr("allowedReferences"), - .disallowedReferences = parsed.getStringSetAttr("disallowedReferences").value_or(StringSet{}), - .allowedRequisites = parsed.getStringSetAttr("allowedRequisites"), - .disallowedRequisites = parsed.getStringSetAttr("disallowedRequisites").value_or(StringSet{}), + .allowedReferences = getStringSetAttr(env, parsed, "allowedReferences"), + .disallowedReferences = getStringSetAttr(env, parsed, "disallowedReferences").value_or(StringSet{}), + .allowedRequisites = getStringSetAttr(env, parsed, "allowedRequisites"), + .disallowedRequisites = getStringSetAttr(env, parsed, "disallowedRequisites").value_or(StringSet{}), }; } }(), @@ -102,8 +177,8 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars [&] { std::map res; - if (auto structuredAttrs = parsed.structuredAttrs.get()) { - if (auto udr = get(*structuredAttrs, "unsafeDiscardReferences")) { + if (parsed) { + if (auto udr = get(parsed->structuredAttrs, "unsafeDiscardReferences")) { for (auto & [outputName, output] : getObject(*udr)) { if (!output.is_boolean()) throw Error("attribute 'unsafeDiscardReferences.\"%s\"' must be a Boolean", outputName); @@ -117,8 +192,8 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars .passAsFile = [&] { StringSet res; - if (auto * passAsFileString = get(parsed.env, "passAsFile")) { - if (parsed.hasStructuredAttrs()) { + 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"); @@ -133,8 +208,8 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars [&] { std::map ret; - if (auto structuredAttrs = parsed.structuredAttrs.get()) { - auto e = optionalValueAt(*structuredAttrs, "exportReferencesGraph"); + if (parsed) { + auto e = optionalValueAt(parsed->structuredAttrs, "exportReferencesGraph"); if (!e || !e->is_object()) return ret; for (auto & [key, storePathsJson] : getObject(*e)) { @@ -144,10 +219,10 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars ret.insert_or_assign(key, std::move(storePaths)); } } else { - auto s = getOr(parsed.env, "exportReferencesGraph", ""); + auto s = getOr(env, "exportReferencesGraph", ""); Strings ss = tokenizeString(s); if (ss.size() % 2 != 0) - throw BuildError("odd number of tokens in 'exportReferencesGraph': '%1%'", s); + 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_.-]*"); @@ -163,15 +238,15 @@ DerivationOptions::fromParsedDerivation(const StoreDirConfig & store, const Pars return ret; }(), .additionalSandboxProfile = - parsed.getStringAttr("__sandboxProfile").value_or(defaults.additionalSandboxProfile), - .noChroot = parsed.getBoolAttr("__noChroot", defaults.noChroot), - .impureHostDeps = parsed.getStringSetAttr("__impureHostDeps").value_or(defaults.impureHostDeps), - .impureEnvVars = parsed.getStringSetAttr("impureEnvVars").value_or(defaults.impureEnvVars), - .allowLocalNetworking = parsed.getBoolAttr("__darwinAllowLocalNetworking", defaults.allowLocalNetworking), + 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 = - parsed.getStringSetAttr("requiredSystemFeatures").value_or(defaults.requiredSystemFeatures), - .preferLocalBuild = parsed.getBoolAttr("preferLocalBuild", defaults.preferLocalBuild), - .allowSubstitutes = parsed.getBoolAttr("allowSubstitutes", defaults.allowSubstitutes), + getStringSetAttr(env, parsed, "requiredSystemFeatures").value_or(defaults.requiredSystemFeatures), + .preferLocalBuild = getBoolAttr(env, parsed, "preferLocalBuild", defaults.preferLocalBuild), + .allowSubstitutes = getBoolAttr(env, parsed, "allowSubstitutes", defaults.allowSubstitutes), }; } diff --git a/src/libstore/derivation-options.hh b/src/libstore/derivation-options.hh index 4a44e48d263..ddc3f3bfe47 100644 --- a/src/libstore/derivation-options.hh +++ b/src/libstore/derivation-options.hh @@ -14,16 +14,16 @@ namespace nix { class Store; struct BasicDerivation; -class ParsedDerivation; +struct StructuredAttrs; /** * This represents all the special options on a `Derivation`. * * Currently, these options are parsed from the environment variables - * with the aid of `ParsedDerivation`. + * with the aid of `StructuredAttrs`. * * The first goal of this data type is to make sure that no other code - * uses `ParsedDerivation` to ad-hoc parse some additional options. That + * uses `StructuredAttrs` to ad-hoc parse some additional options. That * ensures this data type is up to date and fully correct. * * The second goal of this data type is to allow an alternative to @@ -174,8 +174,8 @@ struct DerivationOptions * (e.g. JSON) but is necessary for supporing old formats (e.g. * ATerm). */ - static DerivationOptions - fromParsedDerivation(const StoreDirConfig & store, const ParsedDerivation & parsed, bool shouldWarn = true); + static DerivationOptions fromStructuredAttrs( + const StoreDirConfig & store, const StringMap & env, const StructuredAttrs * parsed, bool shouldWarn = true); /** * @param drv Must be the same derivation we parsed this from. In diff --git a/src/libstore/misc.cc b/src/libstore/misc.cc index ebd15f0bd34..81a90805a22 100644 --- a/src/libstore/misc.cc +++ b/src/libstore/misc.cc @@ -222,10 +222,13 @@ void Store::queryMissing(const std::vector & targets, if (knownOutputPaths && invalid.empty()) return; auto drv = make_ref(derivationFromPath(drvPath)); - ParsedDerivation parsedDrv(drv->env); + auto parsedDrv = StructuredAttrs::tryParse(drv->env); DerivationOptions drvOptions; try { - drvOptions = DerivationOptions::fromParsedDerivation(*this, parsedDrv); + drvOptions = DerivationOptions::fromStructuredAttrs( + *this, + drv->env, + parsedDrv ? &*parsedDrv : nullptr); } catch (Error & e) { e.addTrace({}, "while parsing derivation '%s'", printStorePath(drvPath)); throw; diff --git a/src/libstore/parsed-derivations.cc b/src/libstore/parsed-derivations.cc index d7e9dbc053c..665ac2f8d3e 100644 --- a/src/libstore/parsed-derivations.cc +++ b/src/libstore/parsed-derivations.cc @@ -1,4 +1,6 @@ #include "parsed-derivations.hh" +#include "store-api.hh" +#include "derivations.hh" #include "derivation-options.hh" #include @@ -6,94 +8,20 @@ namespace nix { -ParsedDerivation::ParsedDerivation(const StringPairs & env) - : env(env) +std::optional StructuredAttrs::tryParse(const StringPairs & env) { /* Parse the __json attribute, if any. */ auto jsonAttr = env.find("__json"); if (jsonAttr != env.end()) { try { - structuredAttrs = std::make_unique(nlohmann::json::parse(jsonAttr->second)); + return StructuredAttrs { + .structuredAttrs = nlohmann::json::parse(jsonAttr->second), + }; } catch (std::exception & e) { throw Error("cannot process __json attribute: %s", e.what()); } } -} - -ParsedDerivation::~ParsedDerivation() { } - -std::optional ParsedDerivation::getStringAttr(const std::string & name) const -{ - if (structuredAttrs) { - auto i = structuredAttrs->find(name); - if (i == structuredAttrs->end()) - return {}; - else { - if (!i->is_string()) - throw Error("attribute '%s' of must be a string", name); - return i->get(); - } - } else { - auto i = env.find(name); - if (i == env.end()) - return {}; - else - return i->second; - } -} - -bool ParsedDerivation::getBoolAttr(const std::string & name, bool def) const -{ - if (structuredAttrs) { - auto i = structuredAttrs->find(name); - if (i == structuredAttrs->end()) - return def; - else { - if (!i->is_boolean()) - throw Error("attribute '%s' must be a Boolean", name); - return i->get(); - } - } else { - auto i = env.find(name); - if (i == env.end()) - return def; - else - return i->second == "1"; - } -} - -std::optional ParsedDerivation::getStringsAttr(const std::string & name) const -{ - if (structuredAttrs) { - auto i = structuredAttrs->find(name); - if (i == structuredAttrs->end()) - return {}; - else { - if (!i->is_array()) - throw Error("attribute '%s' must be a list of strings", name); - Strings 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.push_back(j->get()); - } - return res; - } - } else { - auto i = env.find(name); - if (i == env.end()) - return {}; - else - return tokenizeString(i->second); - } -} - -std::optional ParsedDerivation::getStringSetAttr(const std::string & name) const -{ - auto ss = getStringsAttr(name); - return ss - ? (std::optional{StringSet{ss->begin(), ss->end()}}) - : (std::optional{}); + return {}; } static std::regex shVarName("[A-Za-z_][A-Za-z0-9_]*"); @@ -152,15 +80,14 @@ static nlohmann::json pathInfoToJSON( return jsonList; } -std::optional ParsedDerivation::prepareStructuredAttrs( +nlohmann::json StructuredAttrs::prepareStructuredAttrs( Store & store, const DerivationOptions & drvOptions, const StorePathSet & inputPaths, - const DerivationOutputs & outputs) + const DerivationOutputs & outputs) const { - if (!structuredAttrs) return std::nullopt; - - auto json = *structuredAttrs; + /* Copy to then modify */ + auto json = structuredAttrs; /* Add an "outputs" object containing the output paths. */ nlohmann::json outputsJson; @@ -177,12 +104,7 @@ std::optional ParsedDerivation::prepareStructuredAttrs( return json; } -/* As a convenience to bash scripts, write a shell file that - maps all attributes that are representable in bash - - namely, strings, integers, nulls, Booleans, and arrays and - objects consisting entirely of those values. (So nested - arrays or objects are not supported.) */ -std::string writeStructuredAttrsShell(const nlohmann::json & json) +std::string StructuredAttrs::writeShell(const nlohmann::json & json) { auto handleSimpleType = [](const nlohmann::json & value) -> std::optional { diff --git a/src/libstore/parsed-derivations.hh b/src/libstore/parsed-derivations.hh index fc3107e2873..edf9cfaaea1 100644 --- a/src/libstore/parsed-derivations.hh +++ b/src/libstore/parsed-derivations.hh @@ -1,54 +1,43 @@ #pragma once ///@file -#include "derivations.hh" -#include "store-api.hh" +#include -#include +#include "types.hh" +#include "path.hh" namespace nix { +class Store; struct DerivationOptions; +struct DerivationOutput; -class ParsedDerivation -{ - const StringPairs & env; - std::unique_ptr structuredAttrs; - - std::optional getStringAttr(const std::string & name) const; - - bool getBoolAttr(const std::string & name, bool def = false) const; - - std::optional getStringsAttr(const std::string & name) const; - - std::optional getStringSetAttr(const std::string & name) const; - - /** - * Only `DerivationOptions` is allowed to parse individual fields - * from `ParsedDerivation`. This ensure that it includes all - * derivation options, and, the likes of `LocalDerivationGoal` are - * incapable of more ad-hoc options. - */ - friend struct DerivationOptions; +typedef std::map DerivationOutputs; -public: - - ParsedDerivation(const StringPairs & env); - - ~ParsedDerivation(); +struct StructuredAttrs +{ + nlohmann::json structuredAttrs; - bool hasStructuredAttrs() const - { - return static_cast(structuredAttrs); - } + static std::optional tryParse(const StringPairs & env); - std::optional prepareStructuredAttrs( + nlohmann::json prepareStructuredAttrs( Store & store, const DerivationOptions & drvOptions, const StorePathSet & inputPaths, - const DerivationOutputs & outputs); -}; + const DerivationOutputs & outputs) const; -std::string writeStructuredAttrsShell(const nlohmann::json & json); + /** + * As a convenience to bash scripts, write a shell file that + * maps all attributes that are representable in bash - + * namely, strings, integers, nulls, Booleans, and arrays and + * objects consisting entirely of those values. (So nested + * arrays or objects are not supported.) + * + * @param prepared This should be the result of + * `prepareStructuredAttrs`, *not* the original `structuredAttrs` + * field. + */ + static std::string writeShell(const nlohmann::json & prepared); +}; } diff --git a/src/libstore/unix/build/local-derivation-goal.cc b/src/libstore/unix/build/local-derivation-goal.cc index 42d40888722..679c9e4aa7e 100644 --- a/src/libstore/unix/build/local-derivation-goal.cc +++ b/src/libstore/unix/build/local-derivation-goal.cc @@ -616,7 +616,7 @@ void LocalDerivationGoal::startBuilder() writeStructuredAttrs(); /* Handle exportReferencesGraph(), if set. */ - if (!parsedDrv->hasStructuredAttrs()) { + if (!parsedDrv) { for (auto & [fileName, storePathSet] : drvOptions->exportReferencesGraph) { /* Write closure info to . */ writeFile(tmpDir + "/" + fileName, @@ -1117,7 +1117,7 @@ void LocalDerivationGoal::initTmpDir() /* In non-structured mode, set all bindings either directory in the environment or via a file, as specified by `DerivationOptions::passAsFile`. */ - if (!parsedDrv->hasStructuredAttrs()) { + if (!parsedDrv) { for (auto & i : drv->env) { if (drvOptions->passAsFile.find(i.first) == drvOptions->passAsFile.end()) { env[i.first] = i.second; @@ -1218,13 +1218,12 @@ void LocalDerivationGoal::initEnv() void LocalDerivationGoal::writeStructuredAttrs() { - if (auto structAttrsJson = parsedDrv->prepareStructuredAttrs( + if (parsedDrv) { + auto json = parsedDrv->prepareStructuredAttrs( worker.store, *drvOptions, inputPaths, - drv->outputs)) - { - auto json = structAttrsJson.value(); + drv->outputs); nlohmann::json rewritten; for (auto & [i, v] : json["outputs"].get()) { /* The placeholder must have a rewrite, so we use it to cover both the @@ -1234,7 +1233,7 @@ void LocalDerivationGoal::writeStructuredAttrs() json["outputs"] = rewritten; - auto jsonSh = writeStructuredAttrsShell(json); + auto jsonSh = StructuredAttrs::writeShell(json); writeFile(tmpDir + "/.attrs.sh", rewriteStrings(jsonSh, inputRewrites)); chownToBuilder(tmpDir + "/.attrs.sh"); diff --git a/src/nix-build/nix-build.cc b/src/nix-build/nix-build.cc index 39270fe8f34..3ac1bdde7b3 100644 --- a/src/nix-build/nix-build.cc +++ b/src/nix-build/nix-build.cc @@ -543,10 +543,13 @@ static void main_nix_build(int argc, char * * argv) env["NIX_STORE"] = store->storeDir; env["NIX_BUILD_CORES"] = std::to_string(settings.buildCores); - ParsedDerivation parsedDrv(drv.env); + auto parsedDrv = StructuredAttrs::tryParse(drv.env); DerivationOptions drvOptions; try { - drvOptions = DerivationOptions::fromParsedDerivation(*store, parsedDrv); + drvOptions = DerivationOptions::fromStructuredAttrs( + *store, + drv.env, + parsedDrv ? &*parsedDrv : nullptr); } catch (Error & e) { e.addTrace({}, "while parsing derivation '%s'", store->printStorePath(packageInfo.requireDrvPath())); throw; @@ -565,7 +568,7 @@ static void main_nix_build(int argc, char * * argv) std::string structuredAttrsRC; - if (parsedDrv.hasStructuredAttrs()) { + if (parsedDrv) { StorePathSet inputs; std::function::ChildNode &)> accumInputClosure; @@ -583,24 +586,22 @@ static void main_nix_build(int argc, char * * argv) for (const auto & [inputDrv, inputNode] : drv.inputDrvs.map) accumInputClosure(inputDrv, inputNode); - if (auto structAttrs = parsedDrv.prepareStructuredAttrs( - *store, - drvOptions, - inputs, - drv.outputs)) - { - auto json = structAttrs.value(); - structuredAttrsRC = writeStructuredAttrsShell(json); + auto json = parsedDrv->prepareStructuredAttrs( + *store, + drvOptions, + inputs, + drv.outputs); - auto attrsJSON = (tmpDir.path() / ".attrs.json").string(); - writeFile(attrsJSON, json.dump()); + structuredAttrsRC = StructuredAttrs::writeShell(json); - auto attrsSH = (tmpDir.path() / ".attrs.sh").string(); - writeFile(attrsSH, structuredAttrsRC); + auto attrsJSON = (tmpDir.path() / ".attrs.json").string(); + writeFile(attrsJSON, json.dump()); - env["NIX_ATTRS_SH_FILE"] = attrsSH; - env["NIX_ATTRS_JSON_FILE"] = attrsJSON; - } + auto attrsSH = (tmpDir.path() / ".attrs.sh").string(); + writeFile(attrsSH, structuredAttrsRC); + + env["NIX_ATTRS_SH_FILE"] = attrsSH; + env["NIX_ATTRS_JSON_FILE"] = attrsJSON; } /* Run a shell using the derivation's environment. For