lix/src/nix/show-derivation.cc

129 lines
4.1 KiB
C++
Raw Normal View History

// FIXME: integrate this with nix path-info?
2020-07-24 18:44:31 +00:00
// FIXME: rename to 'nix store show-derivation' or 'nix debug show-derivation'?
#include "command.hh"
#include "common-args.hh"
#include "store-api.hh"
#include "archive.hh"
#include "json.hh"
#include "derivations.hh"
using namespace nix;
struct CmdShowDerivation : InstallablesCommand
{
bool recursive = false;
CmdShowDerivation()
{
2020-05-04 20:40:19 +00:00
addFlag({
.longName = "recursive",
.shortName = 'r',
.description = "include the dependencies of the specified derivations",
.handler = {&recursive, true}
});
}
std::string description() override
{
return "show the contents of a store derivation";
}
Examples examples() override
{
return {
Example{
"To show the store derivation that results from evaluating the Hello package:",
2020-07-15 18:28:16 +00:00
"nix show-derivation nixpkgs#hello"
},
Example{
"To show the full derivation graph (if available) that produced your NixOS system:",
"nix show-derivation -r /run/current-system"
},
};
}
2020-05-05 13:18:23 +00:00
Category category() override { return catUtility; }
void run(ref<Store> store) override
{
auto drvPaths = toDerivations(store, installables, true);
if (recursive) {
StorePathSet closure;
store->computeFSClosure(drvPaths, closure);
drvPaths = std::move(closure);
}
{
JSONObject jsonRoot(std::cout, true);
for (auto & drvPath : drvPaths) {
if (!drvPath.isDerivation()) continue;
auto drvObj(jsonRoot.object(store->printStorePath(drvPath)));
auto drv = store->readDerivation(drvPath);
{
auto outputsObj(drvObj.object("outputs"));
2020-08-14 18:51:31 +00:00
for (auto & [_outputName, output] : drv.outputs) {
auto & outputName = _outputName; // work around clang bug
auto outputObj { outputsObj.object(outputName) };
std::visit(overloaded {
[&](DerivationOutputInputAddressed doi) {
2020-08-07 19:09:26 +00:00
outputObj.attr("path", store->printStorePath(doi.path));
},
[&](DerivationOutputCAFixed dof) {
outputObj.attr("path", store->printStorePath(dof.path(*store, drv.name, outputName)));
outputObj.attr("hashAlgo", dof.hash.printMethodAlgo());
outputObj.attr("hash", dof.hash.hash.to_string(Base16, false));
},
[&](DerivationOutputCAFloating dof) {
outputObj.attr("hashAlgo", makeFileIngestionPrefix(dof.method) + printHashType(dof.hashType));
},
[&](DerivationOutputDeferred) {},
}, output.output);
}
}
{
auto inputsList(drvObj.list("inputSrcs"));
for (auto & input : drv.inputSrcs)
inputsList.elem(store->printStorePath(input));
}
{
auto inputDrvsObj(drvObj.object("inputDrvs"));
for (auto & input : drv.inputDrvs) {
auto inputList(inputDrvsObj.list(store->printStorePath(input.first)));
for (auto & outputId : input.second)
inputList.elem(outputId);
}
}
drvObj.attr("platform", drv.platform);
drvObj.attr("builder", drv.builder);
{
auto argsList(drvObj.list("args"));
for (auto & arg : drv.args)
argsList.elem(arg);
}
{
auto envObj(drvObj.object("env"));
for (auto & var : drv.env)
envObj.attr(var.first, var.second);
}
}
}
std::cout << "\n";
}
};
static auto rCmdShowDerivation = registerCommand<CmdShowDerivation>("show-derivation");