forked from lix-project/lix
44fd7a05b6
This resolves #3810 by changing the behavior of `max-jobs = 0`, so that specifying the option also avoids local building of derivations with the attribute `preferLocalBuild = true`.
125 lines
3.6 KiB
C++
125 lines
3.6 KiB
C++
#include "parsed-derivations.hh"
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
namespace nix {
|
|
|
|
ParsedDerivation::ParsedDerivation(const StorePath & drvPath, BasicDerivation & drv)
|
|
: drvPath(drvPath), drv(drv)
|
|
{
|
|
/* Parse the __json attribute, if any. */
|
|
auto jsonAttr = drv.env.find("__json");
|
|
if (jsonAttr != drv.env.end()) {
|
|
try {
|
|
structuredAttrs = std::make_unique<nlohmann::json>(nlohmann::json::parse(jsonAttr->second));
|
|
} catch (std::exception & e) {
|
|
throw Error("cannot process __json attribute of '%s': %s", drvPath.to_string(), e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
ParsedDerivation::~ParsedDerivation() { }
|
|
|
|
std::optional<std::string> 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 derivation '%s' must be a string", name, drvPath.to_string());
|
|
return i->get<std::string>();
|
|
}
|
|
} else {
|
|
auto i = drv.env.find(name);
|
|
if (i == drv.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' of derivation '%s' must be a Boolean", name, drvPath.to_string());
|
|
return i->get<bool>();
|
|
}
|
|
} else {
|
|
auto i = drv.env.find(name);
|
|
if (i == drv.env.end())
|
|
return def;
|
|
else
|
|
return i->second == "1";
|
|
}
|
|
}
|
|
|
|
std::optional<Strings> 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' of derivation '%s' must be a list of strings", name, drvPath.to_string());
|
|
Strings res;
|
|
for (auto j = i->begin(); j != i->end(); ++j) {
|
|
if (!j->is_string())
|
|
throw Error("attribute '%s' of derivation '%s' must be a list of strings", name, drvPath.to_string());
|
|
res.push_back(j->get<std::string>());
|
|
}
|
|
return res;
|
|
}
|
|
} else {
|
|
auto i = drv.env.find(name);
|
|
if (i == drv.env.end())
|
|
return {};
|
|
else
|
|
return tokenizeString<Strings>(i->second);
|
|
}
|
|
}
|
|
|
|
StringSet ParsedDerivation::getRequiredSystemFeatures() const
|
|
{
|
|
StringSet res;
|
|
for (auto & i : getStringsAttr("requiredSystemFeatures").value_or(Strings()))
|
|
res.insert(i);
|
|
return res;
|
|
}
|
|
|
|
bool ParsedDerivation::canBuildLocally(Store & localStore) 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())
|
|
if (!localStore.systemFeatures.get().count(feature)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ParsedDerivation::willBuildLocally(Store & localStore) const
|
|
{
|
|
return getBoolAttr("preferLocalBuild") && canBuildLocally(localStore);
|
|
}
|
|
|
|
bool ParsedDerivation::substitutesAllowed() const
|
|
{
|
|
return getBoolAttr("allowSubstitutes", true);
|
|
}
|
|
|
|
}
|