2018-11-29 18:18:36 +00:00
|
|
|
#include "command.hh"
|
|
|
|
#include "common-args.hh"
|
|
|
|
#include "shared.hh"
|
|
|
|
#include "progress-bar.hh"
|
|
|
|
#include "eval.hh"
|
2019-05-29 15:25:41 +00:00
|
|
|
#include "eval-inline.hh"
|
2019-06-05 14:51:54 +00:00
|
|
|
#include "flake/flake.hh"
|
2019-05-29 15:25:41 +00:00
|
|
|
#include "get-drvs.hh"
|
|
|
|
#include "store-api.hh"
|
2019-06-17 15:59:57 +00:00
|
|
|
#include "derivations.hh"
|
2019-09-19 18:15:42 +00:00
|
|
|
#include "attr-path.hh"
|
2020-01-21 15:27:53 +00:00
|
|
|
#include "fetchers/fetchers.hh"
|
|
|
|
#include "fetchers/registry.hh"
|
2020-01-29 23:58:55 +00:00
|
|
|
#include "json.hh"
|
2019-04-16 12:10:05 +00:00
|
|
|
|
2019-02-27 18:54:18 +00:00
|
|
|
#include <nlohmann/json.hpp>
|
2019-03-29 15:18:25 +00:00
|
|
|
#include <queue>
|
2019-05-28 18:34:02 +00:00
|
|
|
#include <iomanip>
|
2018-11-29 18:18:36 +00:00
|
|
|
|
|
|
|
using namespace nix;
|
2019-05-29 13:31:07 +00:00
|
|
|
using namespace nix::flake;
|
2018-11-29 18:18:36 +00:00
|
|
|
|
2019-05-22 11:46:07 +00:00
|
|
|
class FlakeCommand : virtual Args, public EvalCommand, public MixFlakeOptions
|
2019-05-16 20:48:16 +00:00
|
|
|
{
|
2019-10-08 14:30:04 +00:00
|
|
|
std::string flakeUrl = ".";
|
2019-05-16 20:48:16 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
FlakeCommand()
|
|
|
|
{
|
2019-10-08 14:30:04 +00:00
|
|
|
expectArg("flake-url", &flakeUrl, true);
|
2019-05-16 20:48:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FlakeRef getFlakeRef()
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
return parseFlakeRef(flakeUrl, absPath(".")); //FIXME
|
2019-05-16 20:48:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Flake getFlake()
|
|
|
|
{
|
|
|
|
auto evalState = getEvalState();
|
2020-01-29 20:01:34 +00:00
|
|
|
return flake::getFlake(*evalState, getFlakeRef(), lockFlags.useRegistries);
|
2019-05-22 11:46:07 +00:00
|
|
|
}
|
|
|
|
|
2020-01-22 19:59:59 +00:00
|
|
|
LockedFlake lockFlake()
|
2019-05-22 11:46:07 +00:00
|
|
|
{
|
2020-01-29 20:01:34 +00:00
|
|
|
return flake::lockFlake(*getEvalState(), getFlakeRef(), lockFlags);
|
2019-05-16 20:48:16 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct CmdFlakeList : EvalCommand
|
2018-11-29 18:18:36 +00:00
|
|
|
{
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "list available Nix flakes";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
using namespace fetchers;
|
2018-11-29 18:18:36 +00:00
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
auto registries = getRegistries(store);
|
2019-04-17 12:03:04 +00:00
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
stopProgressBar();
|
2019-04-17 12:03:04 +00:00
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
for (auto & registry : registries) {
|
|
|
|
for (auto & entry : registry->entries) {
|
|
|
|
// FIXME: format nicely
|
|
|
|
std::cout << fmt("%s %s %s\n",
|
|
|
|
registry->type == Registry::Flag ? "flags " :
|
|
|
|
registry->type == Registry::User ? "user " :
|
|
|
|
"global",
|
|
|
|
entry.first->to_string(),
|
|
|
|
entry.second->to_string());
|
|
|
|
}
|
|
|
|
}
|
2018-11-29 18:18:36 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
static void printFlakeInfo(const Store & store, const Flake & flake)
|
2019-05-28 11:21:06 +00:00
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
std::cout << fmt("URL: %s\n", flake.resolvedRef.input->to_string());
|
2019-07-11 11:54:53 +00:00
|
|
|
std::cout << fmt("Edition: %s\n", flake.edition);
|
2020-01-22 16:20:21 +00:00
|
|
|
if (flake.description)
|
|
|
|
std::cout << fmt("Description: %s\n", *flake.description);
|
2020-01-21 15:27:53 +00:00
|
|
|
std::cout << fmt("Path: %s\n", store.printStorePath(flake.sourceInfo->storePath));
|
2020-02-01 22:54:20 +00:00
|
|
|
if (auto rev = flake.resolvedRef.input->getRev())
|
|
|
|
std::cout << fmt("Revision: %s\n", rev->to_string(Base16, false));
|
2020-02-01 15:41:54 +00:00
|
|
|
if (flake.sourceInfo->info.revCount)
|
|
|
|
std::cout << fmt("Revisions: %s\n", *flake.sourceInfo->info.revCount);
|
|
|
|
if (flake.sourceInfo->info.lastModified)
|
2020-01-21 15:27:53 +00:00
|
|
|
std::cout << fmt("Last modified: %s\n",
|
2020-02-01 15:41:54 +00:00
|
|
|
std::put_time(std::localtime(&*flake.sourceInfo->info.lastModified), "%F %T"));
|
2019-03-21 08:30:16 +00:00
|
|
|
}
|
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
static nlohmann::json flakeToJson(const Store & store, const Flake & flake)
|
2019-05-28 11:21:06 +00:00
|
|
|
{
|
2019-05-28 12:01:57 +00:00
|
|
|
nlohmann::json j;
|
2020-01-22 16:20:21 +00:00
|
|
|
if (flake.description)
|
|
|
|
j["description"] = *flake.description;
|
2019-07-11 11:54:53 +00:00
|
|
|
j["edition"] = flake.edition;
|
2020-01-21 15:27:53 +00:00
|
|
|
j["url"] = flake.resolvedRef.input->to_string();
|
2020-02-01 22:54:20 +00:00
|
|
|
if (auto rev = flake.resolvedRef.input->getRev())
|
|
|
|
j["revision"] = rev->to_string(Base16, false);
|
2020-02-01 15:41:54 +00:00
|
|
|
if (flake.sourceInfo->info.revCount)
|
|
|
|
j["revCount"] = *flake.sourceInfo->info.revCount;
|
|
|
|
if (flake.sourceInfo->info.lastModified)
|
|
|
|
j["lastModified"] = *flake.sourceInfo->info.lastModified;
|
2020-01-21 15:27:53 +00:00
|
|
|
j["path"] = store.printStorePath(flake.sourceInfo->storePath);
|
2019-05-28 12:01:57 +00:00
|
|
|
return j;
|
|
|
|
}
|
|
|
|
|
2019-05-16 20:48:16 +00:00
|
|
|
struct CmdFlakeUpdate : FlakeCommand
|
2019-02-21 05:53:01 +00:00
|
|
|
{
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "update flake lock file";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
2020-02-01 11:26:05 +00:00
|
|
|
/* Use --refresh by default for 'nix flake update'. */
|
|
|
|
settings.tarballTtl = 0;
|
|
|
|
|
2020-01-22 19:59:59 +00:00
|
|
|
lockFlake();
|
2019-02-21 05:53:01 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-05-29 21:09:23 +00:00
|
|
|
static void enumerateOutputs(EvalState & state, Value & vFlake,
|
2019-09-10 13:25:10 +00:00
|
|
|
std::function<void(const std::string & name, Value & vProvide, const Pos & pos)> callback)
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
{
|
|
|
|
state.forceAttrs(vFlake);
|
|
|
|
|
2019-09-22 19:53:01 +00:00
|
|
|
auto aOutputs = vFlake.attrs->get(state.symbols.create("outputs"));
|
|
|
|
assert(aOutputs);
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
|
2019-09-22 19:53:01 +00:00
|
|
|
state.forceAttrs(*(*aOutputs)->value);
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
|
2019-09-22 19:53:01 +00:00
|
|
|
for (auto & attr : *((*aOutputs)->value->attrs))
|
2019-09-10 13:25:10 +00:00
|
|
|
callback(attr.name, *attr.value, *attr.pos);
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
}
|
|
|
|
|
2019-05-16 20:48:16 +00:00
|
|
|
struct CmdFlakeInfo : FlakeCommand, MixJSON
|
2019-02-21 05:53:01 +00:00
|
|
|
{
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "list info about a given flake";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
if (json) {
|
|
|
|
auto state = getEvalState();
|
2020-01-22 19:59:59 +00:00
|
|
|
auto flake = lockFlake();
|
2019-05-29 15:25:41 +00:00
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
auto json = flakeToJson(*store, flake.flake);
|
2019-09-22 19:53:01 +00:00
|
|
|
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
auto vFlake = state->allocValue();
|
|
|
|
flake::callFlake(*state, flake, *vFlake);
|
2019-05-29 15:25:41 +00:00
|
|
|
|
2019-05-29 21:09:23 +00:00
|
|
|
auto outputs = nlohmann::json::object();
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
|
2019-05-29 21:09:23 +00:00
|
|
|
enumerateOutputs(*state,
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
*vFlake,
|
2019-09-10 13:25:10 +00:00
|
|
|
[&](const std::string & name, Value & vProvide, const Pos & pos) {
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
auto provide = nlohmann::json::object();
|
|
|
|
|
|
|
|
if (name == "checks" || name == "packages") {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceAttrs(vProvide, pos);
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
for (auto & aCheck : *vProvide.attrs)
|
|
|
|
provide[aCheck.name] = nlohmann::json::object();
|
|
|
|
}
|
|
|
|
|
2019-05-29 21:09:23 +00:00
|
|
|
outputs[name] = provide;
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
});
|
|
|
|
|
2019-05-29 21:09:23 +00:00
|
|
|
json["outputs"] = std::move(outputs);
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
|
|
|
|
std::cout << json.dump() << std::endl;
|
2019-09-22 19:53:01 +00:00
|
|
|
} else {
|
|
|
|
auto flake = getFlake();
|
|
|
|
stopProgressBar();
|
2020-01-21 15:27:53 +00:00
|
|
|
printFlakeInfo(*store, flake);
|
2019-09-22 19:53:01 +00:00
|
|
|
}
|
nix flake info --json: List the "provides"
It also lists the contents of "checks" and "packages".
For example:
$ nix flake info --json | jq
{
"branch": "HEAD",
"description": "The purely functional package manager",
"epoch": 2019,
"id": "nix",
"lastModified": 1559161142,
"path": "/nix/store/2w2qla8735dbxah8gai8r1nsbf5x4f5d-source",
"provides": {
"checks": {
"binaryTarball": {},
"nix-copy-closure": {},
"perlBindings": {},
"remoteBuilds": {},
"setuid": {}
},
"defaultPackage": {},
"devShell": {},
"hydraJobs": {},
"packages": {
"nix": {},
"nix-perl-bindings": {}
}
},
"revCount": 6955,
"revision": "8cb24e04e8b6cc60e2504733afe78e0eadafcd98",
"uri": "/home/eelco/Dev/nix"
}
Fixes #2820.
2019-05-29 20:17:08 +00:00
|
|
|
}
|
|
|
|
};
|
2019-05-29 15:25:41 +00:00
|
|
|
|
2020-01-31 11:54:52 +00:00
|
|
|
struct CmdFlakeListInputs : FlakeCommand, MixJSON
|
|
|
|
{
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "list flake inputs";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
|
|
|
auto flake = lockFlake();
|
|
|
|
|
2020-01-31 13:01:46 +00:00
|
|
|
stopProgressBar();
|
|
|
|
|
2020-01-31 11:54:52 +00:00
|
|
|
if (json)
|
|
|
|
std::cout << ((LockedInputs &) flake.lockFile).toJson() << "\n";
|
|
|
|
else {
|
|
|
|
std::cout << fmt("%s\n", flake.flake.resolvedRef);
|
|
|
|
|
2020-01-31 13:01:46 +00:00
|
|
|
std::function<void(const LockedInputs & inputs, const std::string & prefix)> recurse;
|
2020-01-31 11:54:52 +00:00
|
|
|
|
2020-01-31 13:01:46 +00:00
|
|
|
recurse = [&](const LockedInputs & inputs, const std::string & prefix)
|
2020-01-31 11:54:52 +00:00
|
|
|
{
|
2020-01-31 13:01:46 +00:00
|
|
|
for (const auto & [i, input] : enumerate(inputs.inputs)) {
|
|
|
|
//auto tree2 = tree.child(i + 1 == inputs.inputs.size());
|
|
|
|
bool last = i + 1 == inputs.inputs.size();
|
|
|
|
std::cout << fmt("%s" ANSI_BOLD "%s" ANSI_NORMAL ": %s\n",
|
|
|
|
prefix + (last ? treeLast : treeConn), input.first, input.second.ref);
|
|
|
|
recurse(input.second, prefix + (last ? treeNull : treeLine));
|
2020-01-31 11:54:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-01-31 13:01:46 +00:00
|
|
|
recurse(flake.lockFile, "");
|
2020-01-31 11:54:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-01-29 23:58:55 +00:00
|
|
|
struct CmdFlakeCheck : FlakeCommand
|
2019-05-29 15:25:41 +00:00
|
|
|
{
|
|
|
|
bool build = true;
|
|
|
|
|
|
|
|
CmdFlakeCheck()
|
|
|
|
{
|
|
|
|
mkFlag()
|
|
|
|
.longName("no-build")
|
|
|
|
.description("do not build checks")
|
|
|
|
.set(&build, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "check whether the flake evaluates and run its tests";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
2019-05-29 19:00:44 +00:00
|
|
|
settings.readOnlyMode = !build;
|
|
|
|
|
2019-05-29 15:25:41 +00:00
|
|
|
auto state = getEvalState();
|
2020-01-22 19:59:59 +00:00
|
|
|
auto flake = lockFlake();
|
2019-05-29 15:25:41 +00:00
|
|
|
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
auto checkSystemName = [&](const std::string & system, const Pos & pos) {
|
|
|
|
// FIXME: what's the format of "system"?
|
|
|
|
if (system.find('-') == std::string::npos)
|
|
|
|
throw Error("'%s' is not a valid system type, at %s", system, pos);
|
|
|
|
};
|
|
|
|
|
2019-09-10 13:25:10 +00:00
|
|
|
auto checkDerivation = [&](const std::string & attrPath, Value & v, const Pos & pos) {
|
2019-05-29 18:57:08 +00:00
|
|
|
try {
|
|
|
|
auto drvInfo = getDerivation(*state, v, false);
|
|
|
|
if (!drvInfo)
|
|
|
|
throw Error("flake attribute '%s' is not a derivation", attrPath);
|
|
|
|
// FIXME: check meta attributes
|
2019-12-11 13:53:30 +00:00
|
|
|
return store->parseStorePath(drvInfo->queryDrvPath());
|
2019-05-29 18:57:08 +00:00
|
|
|
} catch (Error & e) {
|
2019-09-10 13:25:10 +00:00
|
|
|
e.addPrefix(fmt("while checking the derivation '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attrPath, pos));
|
2019-05-29 18:57:08 +00:00
|
|
|
throw;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-12-11 13:53:30 +00:00
|
|
|
std::vector<StorePathWithOutputs> drvPaths;
|
2019-05-29 15:25:41 +00:00
|
|
|
|
2019-09-10 13:25:10 +00:00
|
|
|
auto checkApp = [&](const std::string & attrPath, Value & v, const Pos & pos) {
|
2019-06-17 15:59:57 +00:00
|
|
|
try {
|
|
|
|
auto app = App(*state, v);
|
|
|
|
for (auto & i : app.context) {
|
2019-12-11 13:53:30 +00:00
|
|
|
auto [drvPathS, outputName] = decodeContext(i);
|
|
|
|
auto drvPath = store->parseStorePath(drvPathS);
|
|
|
|
if (!outputName.empty() && drvPath.isDerivation())
|
|
|
|
drvPaths.emplace_back(drvPath);
|
2019-06-17 15:59:57 +00:00
|
|
|
}
|
|
|
|
} catch (Error & e) {
|
2019-09-10 13:25:10 +00:00
|
|
|
e.addPrefix(fmt("while checking the app definition '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attrPath, pos));
|
2019-06-17 15:59:57 +00:00
|
|
|
throw;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-09-10 13:25:10 +00:00
|
|
|
auto checkOverlay = [&](const std::string & attrPath, Value & v, const Pos & pos) {
|
2019-09-10 12:52:22 +00:00
|
|
|
try {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceValue(v, pos);
|
2019-09-10 12:52:22 +00:00
|
|
|
if (v.type != tLambda || v.lambda.fun->matchAttrs || std::string(v.lambda.fun->arg) != "final")
|
|
|
|
throw Error("overlay does not take an argument named 'final'");
|
|
|
|
auto body = dynamic_cast<ExprLambda *>(v.lambda.fun->body);
|
|
|
|
if (!body || body->matchAttrs || std::string(body->arg) != "prev")
|
|
|
|
throw Error("overlay does not take an argument named 'prev'");
|
|
|
|
// FIXME: if we have a 'nixpkgs' input, use it to
|
|
|
|
// evaluate the overlay.
|
|
|
|
} catch (Error & e) {
|
2019-09-10 13:25:10 +00:00
|
|
|
e.addPrefix(fmt("while checking the overlay '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attrPath, pos));
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
auto checkModule = [&](const std::string & attrPath, Value & v, const Pos & pos) {
|
|
|
|
try {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceValue(v, pos);
|
2019-09-10 13:25:10 +00:00
|
|
|
if (v.type == tLambda) {
|
|
|
|
if (!v.lambda.fun->matchAttrs || !v.lambda.fun->formals->ellipsis)
|
|
|
|
throw Error("module must match an open attribute set ('{ config, ... }')");
|
|
|
|
} else if (v.type == tAttrs) {
|
|
|
|
for (auto & attr : *v.attrs)
|
|
|
|
try {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceValue(*attr.value, *attr.pos);
|
2019-09-10 13:25:10 +00:00
|
|
|
} catch (Error & e) {
|
|
|
|
e.addPrefix(fmt("while evaluating the option '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attr.name, *attr.pos));
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
throw Error("module must be a function or an attribute set");
|
|
|
|
// FIXME: if we have a 'nixpkgs' input, use it to
|
|
|
|
// check the module.
|
|
|
|
} catch (Error & e) {
|
|
|
|
e.addPrefix(fmt("while checking the NixOS module '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attrPath, pos));
|
2019-09-10 12:52:22 +00:00
|
|
|
throw;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-09-10 15:39:55 +00:00
|
|
|
std::function<void(const std::string & attrPath, Value & v, const Pos & pos)> checkHydraJobs;
|
|
|
|
|
|
|
|
checkHydraJobs = [&](const std::string & attrPath, Value & v, const Pos & pos) {
|
|
|
|
try {
|
|
|
|
state->forceAttrs(v, pos);
|
|
|
|
|
|
|
|
if (state->isDerivation(v))
|
|
|
|
throw Error("jobset should not be a derivation at top-level");
|
|
|
|
|
|
|
|
for (auto & attr : *v.attrs) {
|
|
|
|
state->forceAttrs(*attr.value, *attr.pos);
|
|
|
|
if (!state->isDerivation(*attr.value))
|
|
|
|
checkHydraJobs(attrPath + "." + (std::string) attr.name,
|
|
|
|
*attr.value, *attr.pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
} catch (Error & e) {
|
|
|
|
e.addPrefix(fmt("while checking the Hydra jobset '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attrPath, pos));
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-09-19 18:15:42 +00:00
|
|
|
auto checkNixOSConfiguration = [&](const std::string & attrPath, Value & v, const Pos & pos) {
|
|
|
|
try {
|
|
|
|
Activity act(*logger, lvlChatty, actUnknown,
|
|
|
|
fmt("checking NixOS configuration '%s'", attrPath));
|
|
|
|
Bindings & bindings(*state->allocBindings(0));
|
|
|
|
auto vToplevel = findAlongAttrPath(*state, "config.system.build.toplevel", bindings, v);
|
|
|
|
state->forceAttrs(*vToplevel, pos);
|
|
|
|
if (!state->isDerivation(*vToplevel))
|
|
|
|
throw Error("attribute 'config.system.build.toplevel' is not a derivation");
|
|
|
|
} catch (Error & e) {
|
|
|
|
e.addPrefix(fmt("while checking the NixOS configuration '" ANSI_BOLD "%s" ANSI_NORMAL "' at %s:\n", attrPath, pos));
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-05-29 15:25:41 +00:00
|
|
|
{
|
|
|
|
Activity act(*logger, lvlInfo, actUnknown, "evaluating flake");
|
|
|
|
|
|
|
|
auto vFlake = state->allocValue();
|
|
|
|
flake::callFlake(*state, flake, *vFlake);
|
|
|
|
|
2019-05-29 21:09:23 +00:00
|
|
|
enumerateOutputs(*state,
|
2019-05-29 15:25:41 +00:00
|
|
|
*vFlake,
|
2019-09-10 13:25:10 +00:00
|
|
|
[&](const std::string & name, Value & vOutput, const Pos & pos) {
|
2019-05-29 15:25:41 +00:00
|
|
|
Activity act(*logger, lvlChatty, actUnknown,
|
|
|
|
fmt("checking flake output '%s'", name));
|
|
|
|
|
|
|
|
try {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceValue(vOutput, pos);
|
2019-05-29 15:25:41 +00:00
|
|
|
|
|
|
|
if (name == "checks") {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceAttrs(vOutput, pos);
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
for (auto & attr : *vOutput.attrs) {
|
|
|
|
checkSystemName(attr.name, *attr.pos);
|
|
|
|
state->forceAttrs(*attr.value, *attr.pos);
|
|
|
|
for (auto & attr2 : *attr.value->attrs) {
|
|
|
|
auto drvPath = checkDerivation(
|
|
|
|
fmt("%s.%s.%s", name, attr.name, attr2.name),
|
|
|
|
*attr2.value, *attr2.pos);
|
|
|
|
if ((std::string) attr.name == settings.thisSystem.get())
|
2019-12-11 13:53:30 +00:00
|
|
|
drvPaths.emplace_back(drvPath);
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
2019-05-29 18:57:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
else if (name == "packages") {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceAttrs(vOutput, pos);
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
for (auto & attr : *vOutput.attrs) {
|
|
|
|
checkSystemName(attr.name, *attr.pos);
|
|
|
|
state->forceAttrs(*attr.value, *attr.pos);
|
|
|
|
for (auto & attr2 : *attr.value->attrs)
|
|
|
|
checkDerivation(
|
|
|
|
fmt("%s.%s.%s", name, attr.name, attr2.name),
|
|
|
|
*attr2.value, *attr2.pos);
|
|
|
|
}
|
2019-05-29 15:25:41 +00:00
|
|
|
}
|
|
|
|
|
2019-06-17 15:59:57 +00:00
|
|
|
else if (name == "apps") {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceAttrs(vOutput, pos);
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
for (auto & attr : *vOutput.attrs) {
|
|
|
|
checkSystemName(attr.name, *attr.pos);
|
|
|
|
state->forceAttrs(*attr.value, *attr.pos);
|
|
|
|
for (auto & attr2 : *attr.value->attrs)
|
|
|
|
checkApp(
|
|
|
|
fmt("%s.%s.%s", name, attr.name, attr2.name),
|
|
|
|
*attr2.value, *attr2.pos);
|
|
|
|
}
|
2019-06-17 15:59:57 +00:00
|
|
|
}
|
|
|
|
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
else if (name == "defaultPackage" || name == "devShell") {
|
|
|
|
state->forceAttrs(vOutput, pos);
|
|
|
|
for (auto & attr : *vOutput.attrs) {
|
|
|
|
checkSystemName(attr.name, *attr.pos);
|
|
|
|
checkDerivation(
|
|
|
|
fmt("%s.%s", name, attr.name),
|
|
|
|
*attr.value, *attr.pos);
|
|
|
|
}
|
|
|
|
}
|
2019-05-29 18:57:08 +00:00
|
|
|
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
else if (name == "defaultApp") {
|
|
|
|
state->forceAttrs(vOutput, pos);
|
|
|
|
for (auto & attr : *vOutput.attrs) {
|
|
|
|
checkSystemName(attr.name, *attr.pos);
|
|
|
|
checkApp(
|
|
|
|
fmt("%s.%s", name, attr.name),
|
|
|
|
*attr.value, *attr.pos);
|
|
|
|
}
|
|
|
|
}
|
2019-06-17 15:59:57 +00:00
|
|
|
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
else if (name == "legacyPackages") {
|
|
|
|
state->forceAttrs(vOutput, pos);
|
|
|
|
for (auto & attr : *vOutput.attrs) {
|
|
|
|
checkSystemName(attr.name, *attr.pos);
|
|
|
|
// FIXME: do getDerivations?
|
|
|
|
}
|
|
|
|
}
|
2019-06-18 07:45:14 +00:00
|
|
|
|
2019-09-10 12:52:22 +00:00
|
|
|
else if (name == "overlay")
|
2019-09-10 13:25:10 +00:00
|
|
|
checkOverlay(name, vOutput, pos);
|
|
|
|
|
|
|
|
else if (name == "overlays") {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceAttrs(vOutput, pos);
|
2019-09-10 13:25:10 +00:00
|
|
|
for (auto & attr : *vOutput.attrs)
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
checkOverlay(fmt("%s.%s", name, attr.name),
|
2019-09-10 13:25:10 +00:00
|
|
|
*attr.value, *attr.pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (name == "nixosModule")
|
|
|
|
checkModule(name, vOutput, pos);
|
|
|
|
|
|
|
|
else if (name == "nixosModules") {
|
2019-09-10 15:39:55 +00:00
|
|
|
state->forceAttrs(vOutput, pos);
|
2019-09-10 13:25:10 +00:00
|
|
|
for (auto & attr : *vOutput.attrs)
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
checkModule(fmt("%s.%s", name, attr.name),
|
2019-09-10 13:25:10 +00:00
|
|
|
*attr.value, *attr.pos);
|
|
|
|
}
|
2019-09-10 12:52:22 +00:00
|
|
|
|
2019-09-19 18:15:42 +00:00
|
|
|
else if (name == "nixosConfigurations") {
|
|
|
|
state->forceAttrs(vOutput, pos);
|
|
|
|
for (auto & attr : *vOutput.attrs)
|
Support non-x86_64-linux system types in flakes
A command like
$ nix run nixpkgs#hello
will now build the attribute 'packages.${system}.hello' rather than
'packages.hello'. Note that this does mean that the flake needs to
export an attribute for every system type it supports, and you can't
build on unsupported systems. So 'packages' typically looks like this:
packages = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux"] (system: {
hello = ...;
});
The 'checks', 'defaultPackage', 'devShell', 'apps' and 'defaultApp'
outputs similarly are now attrsets that map system types to
derivations/apps. 'nix flake check' checks that the derivations for
all platforms evaluate correctly, but only builds the derivations in
'checks.${system}'.
Fixes #2861. (That issue also talks about access to ~/.config/nixpkgs
and --arg, but I think it's reasonable to say that flakes shouldn't
support those.)
The alternative to attribute selection is to pass the system type as
an argument to the flake's 'outputs' function, e.g. 'outputs = { self,
nixpkgs, system }: ...'. However, that approach would be at odds with
hermetic evaluation and make it impossible to enumerate the packages
provided by a flake.
2019-10-15 15:52:10 +00:00
|
|
|
checkNixOSConfiguration(fmt("%s.%s", name, attr.name),
|
2019-09-19 18:15:42 +00:00
|
|
|
*attr.value, *attr.pos);
|
|
|
|
}
|
|
|
|
|
2019-09-10 15:39:55 +00:00
|
|
|
else if (name == "hydraJobs")
|
|
|
|
checkHydraJobs(name, vOutput, pos);
|
|
|
|
|
2019-06-17 16:05:32 +00:00
|
|
|
else
|
|
|
|
warn("unknown flake output '%s'", name);
|
|
|
|
|
2019-05-29 15:25:41 +00:00
|
|
|
} catch (Error & e) {
|
|
|
|
e.addPrefix(fmt("while checking flake output '" ANSI_BOLD "%s" ANSI_NORMAL "':\n", name));
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-06-17 15:59:57 +00:00
|
|
|
if (build && !drvPaths.empty()) {
|
2019-05-29 15:25:41 +00:00
|
|
|
Activity act(*logger, lvlInfo, actUnknown, "running flake checks");
|
|
|
|
store->buildPaths(drvPaths);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-03-10 06:05:05 +00:00
|
|
|
struct CmdFlakeAdd : MixEvalArgs, Command
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
std::string fromUrl, toUrl;
|
2019-03-10 06:05:05 +00:00
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "upsert flake in user flake registry";
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdFlakeAdd()
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
expectArg("from-url", &fromUrl);
|
|
|
|
expectArg("to-url", &toUrl);
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void run() override
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
auto fromRef = parseFlakeRef(fromUrl);
|
|
|
|
auto toRef = parseFlakeRef(toUrl);
|
|
|
|
auto userRegistry = fetchers::getUserRegistry();
|
|
|
|
userRegistry->remove(fromRef.input);
|
|
|
|
userRegistry->add(fromRef.input, toRef.input);
|
|
|
|
userRegistry->write(fetchers::getUserRegistryPath());
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct CmdFlakeRemove : virtual Args, MixEvalArgs, Command
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
std::string url;
|
2019-03-10 06:05:05 +00:00
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "remove flake from user flake registry";
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdFlakeRemove()
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
expectArg("url", &url);
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void run() override
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
auto userRegistry = fetchers::getUserRegistry();
|
|
|
|
userRegistry->remove(parseFlakeRef(url).input);
|
|
|
|
userRegistry->write(fetchers::getUserRegistryPath());
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-05-16 20:48:16 +00:00
|
|
|
struct CmdFlakePin : virtual Args, EvalCommand
|
2019-03-10 06:05:05 +00:00
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
std::string url;
|
2019-03-10 06:05:05 +00:00
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
return "pin a flake to its current version in user flake registry";
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CmdFlakePin()
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
expectArg("url", &url);
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
auto ref = parseFlakeRef(url);
|
|
|
|
auto userRegistry = fetchers::getUserRegistry();
|
|
|
|
userRegistry->remove(ref.input);
|
|
|
|
auto [tree, resolved] = ref.resolve(store).input->fetchTree(store);
|
|
|
|
userRegistry->add(ref.input, resolved);
|
2019-03-10 06:05:05 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-04-08 21:36:12 +00:00
|
|
|
struct CmdFlakeInit : virtual Args, Command
|
|
|
|
{
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "create a skeleton 'flake.nix' file in the current directory";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run() override
|
|
|
|
{
|
|
|
|
Path flakeDir = absPath(".");
|
|
|
|
|
|
|
|
if (!pathExists(flakeDir + "/.git"))
|
|
|
|
throw Error("the directory '%s' is not a Git repository", flakeDir);
|
|
|
|
|
|
|
|
Path flakePath = flakeDir + "/flake.nix";
|
|
|
|
|
|
|
|
if (pathExists(flakePath))
|
|
|
|
throw Error("file '%s' already exists", flakePath);
|
|
|
|
|
|
|
|
writeFile(flakePath,
|
2019-04-08 21:39:38 +00:00
|
|
|
#include "flake-template.nix.gen.hh"
|
|
|
|
);
|
2019-04-08 21:36:12 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-05-16 20:48:16 +00:00
|
|
|
struct CmdFlakeClone : FlakeCommand
|
2019-03-21 08:30:16 +00:00
|
|
|
{
|
2019-05-22 11:46:07 +00:00
|
|
|
Path destDir;
|
2019-03-21 08:30:16 +00:00
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "clone flake repository";
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdFlakeClone()
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
mkFlag()
|
|
|
|
.shortName('f')
|
|
|
|
.longName("dest")
|
|
|
|
.label("path")
|
|
|
|
.description("destination path")
|
|
|
|
.dest(&destDir);
|
2019-03-21 08:30:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
2020-01-21 15:27:53 +00:00
|
|
|
if (destDir.empty())
|
|
|
|
throw Error("missing flag '--dest'");
|
2019-03-21 08:30:16 +00:00
|
|
|
|
2020-01-21 15:27:53 +00:00
|
|
|
getFlakeRef().resolve(store).input->clone(destDir);
|
2019-03-21 08:30:16 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-01-29 23:58:55 +00:00
|
|
|
struct CmdFlakeArchive : FlakeCommand, MixJSON, MixDryRun
|
|
|
|
{
|
|
|
|
std::string dstUri;
|
|
|
|
|
|
|
|
CmdFlakeArchive()
|
|
|
|
{
|
|
|
|
mkFlag()
|
|
|
|
.longName("to")
|
|
|
|
.labels({"store-uri"})
|
|
|
|
.description("URI of the destination Nix store")
|
|
|
|
.dest(&dstUri);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "copy a flake and all its inputs to a store";
|
|
|
|
}
|
|
|
|
|
|
|
|
Examples examples() override
|
|
|
|
{
|
|
|
|
return {
|
|
|
|
Example{
|
|
|
|
"To copy the dwarffs flake and its dependencies to a binary cache:",
|
|
|
|
"nix flake archive --to file:///tmp/my-cache dwarffs"
|
|
|
|
},
|
|
|
|
Example{
|
|
|
|
"To fetch the dwarffs flake and its dependencies to the local Nix store:",
|
|
|
|
"nix flake archive dwarffs"
|
|
|
|
},
|
|
|
|
Example{
|
|
|
|
"To print the store paths of the flake sources of NixOps without fetching them:",
|
|
|
|
"nix flake archive --json --dry-run nixops"
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
void run(nix::ref<nix::Store> store) override
|
|
|
|
{
|
|
|
|
auto flake = lockFlake();
|
|
|
|
|
2020-01-30 00:10:26 +00:00
|
|
|
auto jsonRoot = json ? std::optional<JSONObject>(std::cout) : std::nullopt;
|
2020-01-29 23:58:55 +00:00
|
|
|
|
|
|
|
StorePathSet sources;
|
|
|
|
|
|
|
|
sources.insert(flake.flake.sourceInfo->storePath.clone());
|
|
|
|
if (jsonRoot)
|
|
|
|
jsonRoot->attr("path", store->printStorePath(flake.flake.sourceInfo->storePath));
|
|
|
|
|
|
|
|
std::function<void(const LockedInputs & inputs, std::optional<JSONObject> & jsonObj)> traverse;
|
|
|
|
traverse = [&](const LockedInputs & inputs, std::optional<JSONObject> & jsonObj)
|
|
|
|
{
|
|
|
|
auto jsonObj2 = jsonObj ? jsonObj->object("inputs") : std::optional<JSONObject>();
|
|
|
|
for (auto & input : inputs.inputs) {
|
|
|
|
auto jsonObj3 = jsonObj2 ? jsonObj2->object(input.first) : std::optional<JSONObject>();
|
|
|
|
if (!dryRun)
|
|
|
|
input.second.ref.input->fetchTree(store);
|
|
|
|
auto storePath = input.second.computeStorePath(*store);
|
|
|
|
if (jsonObj3)
|
|
|
|
jsonObj3->attr("path", store->printStorePath(storePath));
|
|
|
|
sources.insert(std::move(storePath));
|
|
|
|
traverse(input.second, jsonObj3);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
traverse(flake.lockFile, jsonRoot);
|
|
|
|
|
|
|
|
if (!dryRun && !dstUri.empty()) {
|
|
|
|
ref<Store> dstStore = dstUri.empty() ? openStore() : openStore(dstUri);
|
|
|
|
copyPaths(store, dstStore, sources);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-11-29 18:18:36 +00:00
|
|
|
struct CmdFlake : virtual MultiCommand, virtual Command
|
|
|
|
{
|
|
|
|
CmdFlake()
|
2019-06-18 14:01:35 +00:00
|
|
|
: MultiCommand({
|
|
|
|
{"list", []() { return make_ref<CmdFlakeList>(); }},
|
|
|
|
{"update", []() { return make_ref<CmdFlakeUpdate>(); }},
|
|
|
|
{"info", []() { return make_ref<CmdFlakeInfo>(); }},
|
2020-01-31 11:54:52 +00:00
|
|
|
{"list-inputs", []() { return make_ref<CmdFlakeListInputs>(); }},
|
2019-06-18 14:01:35 +00:00
|
|
|
{"check", []() { return make_ref<CmdFlakeCheck>(); }},
|
|
|
|
{"add", []() { return make_ref<CmdFlakeAdd>(); }},
|
|
|
|
{"remove", []() { return make_ref<CmdFlakeRemove>(); }},
|
|
|
|
{"pin", []() { return make_ref<CmdFlakePin>(); }},
|
|
|
|
{"init", []() { return make_ref<CmdFlakeInit>(); }},
|
|
|
|
{"clone", []() { return make_ref<CmdFlakeClone>(); }},
|
2020-01-29 23:58:55 +00:00
|
|
|
{"archive", []() { return make_ref<CmdFlakeArchive>(); }},
|
2019-06-18 14:01:35 +00:00
|
|
|
})
|
2018-11-29 18:18:36 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "manage Nix flakes";
|
|
|
|
}
|
|
|
|
|
|
|
|
void run() override
|
|
|
|
{
|
|
|
|
if (!command)
|
|
|
|
throw UsageError("'nix flake' requires a sub-command.");
|
2019-10-21 22:21:58 +00:00
|
|
|
command->prepare();
|
2018-11-29 18:18:36 +00:00
|
|
|
command->run();
|
|
|
|
}
|
|
|
|
|
|
|
|
void printHelp(const string & programName, std::ostream & out) override
|
|
|
|
{
|
|
|
|
MultiCommand::printHelp(programName, out);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-06-18 14:01:35 +00:00
|
|
|
static auto r1 = registerCommand<CmdFlake>("flake");
|