2016-02-09 20:28:29 +00:00
|
|
|
#include <algorithm>
|
|
|
|
|
|
|
|
#include "command.hh"
|
|
|
|
#include "common-args.hh"
|
|
|
|
#include "eval.hh"
|
2023-07-31 13:19:19 +00:00
|
|
|
#include "eval-settings.hh"
|
2016-02-09 20:28:29 +00:00
|
|
|
#include "globals.hh"
|
|
|
|
#include "legacy.hh"
|
|
|
|
#include "shared.hh"
|
|
|
|
#include "store-api.hh"
|
2020-04-06 21:57:28 +00:00
|
|
|
#include "filetransfer.hh"
|
2017-08-29 14:18:00 +00:00
|
|
|
#include "finally.hh"
|
2020-06-05 15:01:02 +00:00
|
|
|
#include "loggers.hh"
|
2021-09-13 12:41:28 +00:00
|
|
|
#include "markdown.hh"
|
2016-02-09 20:28:29 +00:00
|
|
|
|
2019-06-17 07:57:22 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <ifaddrs.h>
|
|
|
|
#include <netdb.h>
|
2019-11-01 14:09:42 +00:00
|
|
|
#include <netinet/in.h>
|
2019-06-17 07:57:22 +00:00
|
|
|
|
2020-08-17 15:44:52 +00:00
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
|
2017-08-29 11:21:07 +00:00
|
|
|
extern std::string chrootHelperName;
|
|
|
|
|
|
|
|
void chrootHelper(int argc, char * * argv);
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
namespace nix {
|
|
|
|
|
2019-06-17 07:57:22 +00:00
|
|
|
/* Check if we have a non-loopback/link-local network interface. */
|
|
|
|
static bool haveInternet()
|
|
|
|
{
|
|
|
|
struct ifaddrs * addrs;
|
|
|
|
|
|
|
|
if (getifaddrs(&addrs))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Finally free([&]() { freeifaddrs(addrs); });
|
|
|
|
|
|
|
|
for (auto i = addrs; i; i = i->ifa_next) {
|
|
|
|
if (!i->ifa_addr) continue;
|
|
|
|
if (i->ifa_addr->sa_family == AF_INET) {
|
|
|
|
if (ntohl(((sockaddr_in *) i->ifa_addr)->sin_addr.s_addr) != INADDR_LOOPBACK) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else if (i->ifa_addr->sa_family == AF_INET6) {
|
2019-06-28 13:38:23 +00:00
|
|
|
if (!IN6_IS_ADDR_LOOPBACK(&((sockaddr_in6 *) i->ifa_addr)->sin6_addr) &&
|
|
|
|
!IN6_IS_ADDR_LINKLOCAL(&((sockaddr_in6 *) i->ifa_addr)->sin6_addr))
|
2019-06-17 07:57:22 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-01-31 15:14:47 +00:00
|
|
|
std::string programPath;
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
struct NixArgs : virtual MultiCommand, virtual MixCommonArgs
|
|
|
|
{
|
2019-06-17 07:57:22 +00:00
|
|
|
bool useNet = true;
|
2020-01-28 16:34:48 +00:00
|
|
|
bool refresh = false;
|
2023-01-17 00:13:31 +00:00
|
|
|
bool helpRequested = false;
|
2021-02-17 16:11:14 +00:00
|
|
|
bool showVersion = false;
|
2019-05-15 15:33:56 +00:00
|
|
|
|
2020-12-03 16:55:27 +00:00
|
|
|
NixArgs() : MultiCommand(RegisterCommand::getCommandsFor({})), MixCommonArgs("nix")
|
2016-02-09 20:28:29 +00:00
|
|
|
{
|
2020-05-05 13:18:23 +00:00
|
|
|
categories.clear();
|
2023-03-21 13:43:58 +00:00
|
|
|
categories[catHelp] = "Help commands";
|
2020-05-05 13:18:23 +00:00
|
|
|
categories[Command::catDefault] = "Main commands";
|
|
|
|
categories[catSecondary] = "Infrequently used commands";
|
|
|
|
categories[catUtility] = "Utility/scripting commands";
|
|
|
|
categories[catNixInstallation] = "Commands for upgrading or troubleshooting your Nix installation";
|
|
|
|
|
2020-05-04 20:40:19 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "help",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Show usage information.",
|
2022-10-12 13:09:00 +00:00
|
|
|
.category = miscCategory,
|
2023-01-17 00:13:31 +00:00
|
|
|
.handler = {[this]() { this->helpRequested = true; }},
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
addFlag({
|
|
|
|
.longName = "print-build-logs",
|
|
|
|
.shortName = 'L',
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Print full build logs on standard error.",
|
2021-01-25 18:03:13 +00:00
|
|
|
.category = loggingCategory,
|
2022-08-24 20:36:40 +00:00
|
|
|
.handler = {[&]() { logger->setPrintBuildLogs(true); }},
|
2023-01-17 00:48:39 +00:00
|
|
|
.experimentalFeature = Xp::NixCommand,
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
addFlag({
|
|
|
|
.longName = "version",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Show version information.",
|
2022-10-12 13:09:00 +00:00
|
|
|
.category = miscCategory,
|
2021-02-17 16:11:14 +00:00
|
|
|
.handler = {[&]() { showVersion = true; }},
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
addFlag({
|
2021-02-01 13:11:42 +00:00
|
|
|
.longName = "offline",
|
2021-02-07 19:44:56 +00:00
|
|
|
.aliases = {"no-net"}, // FIXME: remove
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Disable substituters and consider all previously downloaded files up-to-date.",
|
2022-10-12 13:09:00 +00:00
|
|
|
.category = miscCategory,
|
2020-05-04 20:40:19 +00:00
|
|
|
.handler = {[&]() { useNet = false; }},
|
2023-01-17 00:48:39 +00:00
|
|
|
.experimentalFeature = Xp::NixCommand,
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
addFlag({
|
|
|
|
.longName = "refresh",
|
2021-01-13 13:18:04 +00:00
|
|
|
.description = "Consider all previously downloaded files out-of-date.",
|
2022-10-12 13:09:00 +00:00
|
|
|
.category = miscCategory,
|
2020-05-04 20:40:19 +00:00
|
|
|
.handler = {[&]() { refresh = true; }},
|
2023-01-17 00:48:39 +00:00
|
|
|
.experimentalFeature = Xp::NixCommand,
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
2020-12-03 21:45:44 +00:00
|
|
|
}
|
2020-06-04 09:14:19 +00:00
|
|
|
|
2020-12-03 21:45:44 +00:00
|
|
|
std::map<std::string, std::vector<std::string>> aliases = {
|
2020-07-24 18:38:56 +00:00
|
|
|
{"add-to-store", {"store", "add-path"}},
|
|
|
|
{"cat-nar", {"nar", "cat"}},
|
|
|
|
{"cat-store", {"store", "cat"}},
|
|
|
|
{"copy-sigs", {"store", "copy-sigs"}},
|
2020-12-03 21:45:44 +00:00
|
|
|
{"dev-shell", {"develop"}},
|
2020-07-24 18:38:56 +00:00
|
|
|
{"diff-closures", {"store", "diff-closures"}},
|
|
|
|
{"dump-path", {"store", "dump-path"}},
|
2020-12-03 21:45:44 +00:00
|
|
|
{"hash-file", {"hash", "file"}},
|
|
|
|
{"hash-path", {"hash", "path"}},
|
2020-07-24 18:38:56 +00:00
|
|
|
{"ls-nar", {"nar", "ls"}},
|
|
|
|
{"ls-store", {"store", "ls"}},
|
2022-03-22 20:54:49 +00:00
|
|
|
{"make-content-addressable", {"store", "make-content-addressed"}},
|
2020-07-24 18:38:56 +00:00
|
|
|
{"optimise-store", {"store", "optimise"}},
|
|
|
|
{"ping-store", {"store", "ping"}},
|
2021-01-13 22:31:18 +00:00
|
|
|
{"sign-paths", {"store", "sign"}},
|
2023-04-02 17:59:19 +00:00
|
|
|
{"show-derivation", {"derivation", "show"}},
|
2020-12-03 21:45:44 +00:00
|
|
|
{"to-base16", {"hash", "to-base16"}},
|
|
|
|
{"to-base32", {"hash", "to-base32"}},
|
|
|
|
{"to-base64", {"hash", "to-base64"}},
|
2020-07-24 18:38:56 +00:00
|
|
|
{"verify", {"store", "verify"}},
|
2020-12-03 21:45:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
bool aliasUsed = false;
|
|
|
|
|
|
|
|
Strings::iterator rewriteArgs(Strings & args, Strings::iterator pos) override
|
|
|
|
{
|
|
|
|
if (aliasUsed || command || pos == args.end()) return pos;
|
|
|
|
auto arg = *pos;
|
|
|
|
auto i = aliases.find(arg);
|
|
|
|
if (i == aliases.end()) return pos;
|
|
|
|
warn("'%s' is a deprecated alias for '%s'",
|
|
|
|
arg, concatStringsSep(" ", i->second));
|
|
|
|
pos = args.erase(pos);
|
|
|
|
for (auto j = i->second.rbegin(); j != i->second.rend(); ++j)
|
|
|
|
pos = args.insert(pos, *j);
|
|
|
|
aliasUsed = true;
|
|
|
|
return pos;
|
2016-02-09 20:28:29 +00:00
|
|
|
}
|
2017-06-07 14:49:54 +00:00
|
|
|
|
2020-08-18 13:15:35 +00:00
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "a tool for reproducible and declarative configuration management";
|
|
|
|
}
|
2020-12-23 17:33:42 +00:00
|
|
|
|
|
|
|
std::string doc() override
|
|
|
|
{
|
|
|
|
return
|
|
|
|
#include "nix.md"
|
|
|
|
;
|
|
|
|
}
|
2021-01-28 15:04:47 +00:00
|
|
|
|
|
|
|
// Plugins may add new subcommands.
|
|
|
|
void pluginsInited() override
|
|
|
|
{
|
|
|
|
commands = RegisterCommand::getCommandsFor({});
|
|
|
|
}
|
2023-03-21 11:58:14 +00:00
|
|
|
|
|
|
|
std::string dumpCli()
|
|
|
|
{
|
|
|
|
auto res = nlohmann::json::object();
|
|
|
|
|
|
|
|
res["args"] = toJSON();
|
|
|
|
|
|
|
|
auto stores = nlohmann::json::object();
|
|
|
|
for (auto & implem : *Implementations::registered) {
|
|
|
|
auto storeConfig = implem.getConfig();
|
|
|
|
auto storeName = storeConfig->name();
|
2023-04-17 15:58:47 +00:00
|
|
|
auto & j = stores[storeName];
|
|
|
|
j["doc"] = storeConfig->doc();
|
|
|
|
j["settings"] = storeConfig->toJSON();
|
|
|
|
j["experimentalFeature"] = storeConfig->experimentalFeature();
|
2023-03-21 11:58:14 +00:00
|
|
|
}
|
|
|
|
res["stores"] = std::move(stores);
|
|
|
|
|
|
|
|
return res.dump();
|
|
|
|
}
|
2016-02-09 20:28:29 +00:00
|
|
|
};
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
/* Render the help for the specified subcommand to stdout using
|
|
|
|
lowdown. */
|
2023-03-21 11:58:14 +00:00
|
|
|
static void showHelp(std::vector<std::string> subcommand, NixArgs & toplevel)
|
2020-12-02 11:26:09 +00:00
|
|
|
{
|
2021-09-13 12:41:28 +00:00
|
|
|
auto mdName = subcommand.empty() ? "nix" : fmt("nix3-%s", concatStringsSep("-", subcommand));
|
|
|
|
|
|
|
|
evalSettings.restrictEval = false;
|
|
|
|
evalSettings.pureEval = false;
|
|
|
|
EvalState state({}, openStore("dummy://"));
|
|
|
|
|
|
|
|
auto vGenerateManpage = state.allocValue();
|
|
|
|
state.eval(state.parseExprFromString(
|
|
|
|
#include "generate-manpage.nix.gen.hh"
|
2023-04-06 11:15:50 +00:00
|
|
|
, CanonPath::root), *vGenerateManpage);
|
2021-09-13 12:41:28 +00:00
|
|
|
|
|
|
|
auto vUtils = state.allocValue();
|
|
|
|
state.cacheFile(
|
2023-04-06 11:15:50 +00:00
|
|
|
CanonPath("/utils.nix"), CanonPath("/utils.nix"),
|
2021-09-13 12:41:28 +00:00
|
|
|
state.parseExprFromString(
|
|
|
|
#include "utils.nix.gen.hh"
|
2023-04-06 11:15:50 +00:00
|
|
|
, CanonPath::root),
|
2021-09-13 12:41:28 +00:00
|
|
|
*vUtils);
|
|
|
|
|
2023-03-21 11:58:14 +00:00
|
|
|
auto vDump = state.allocValue();
|
|
|
|
vDump->mkString(toplevel.dumpCli());
|
2021-09-13 12:41:28 +00:00
|
|
|
|
|
|
|
auto vRes = state.allocValue();
|
2023-03-21 11:58:14 +00:00
|
|
|
state.callFunction(*vGenerateManpage, *vDump, *vRes, noPos);
|
2021-09-13 12:41:28 +00:00
|
|
|
|
|
|
|
auto attr = vRes->attrs->get(state.symbols.create(mdName + ".md"));
|
|
|
|
if (!attr)
|
|
|
|
throw UsageError("Nix has no subcommand '%s'", concatStringsSep("", subcommand));
|
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
auto markdown = state.forceString(*attr->value, noPos, "while evaluating the lowdown help text");
|
2021-09-13 12:41:28 +00:00
|
|
|
|
|
|
|
RunPager pager;
|
|
|
|
std::cout << renderMarkdownToTerminal(markdown) << "\n";
|
2020-12-02 11:26:09 +00:00
|
|
|
}
|
|
|
|
|
2023-03-21 13:37:09 +00:00
|
|
|
static NixArgs & getNixArgs(Command & cmd)
|
|
|
|
{
|
|
|
|
assert(cmd.parent);
|
|
|
|
MultiCommand * toplevel = cmd.parent;
|
|
|
|
while (toplevel->parent) toplevel = toplevel->parent;
|
|
|
|
return dynamic_cast<NixArgs &>(*toplevel);
|
|
|
|
}
|
|
|
|
|
2020-12-02 11:26:09 +00:00
|
|
|
struct CmdHelp : Command
|
|
|
|
{
|
|
|
|
std::vector<std::string> subcommand;
|
|
|
|
|
|
|
|
CmdHelp()
|
|
|
|
{
|
|
|
|
expectArgs({
|
|
|
|
.label = "subcommand",
|
|
|
|
.handler = {&subcommand},
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
2020-12-10 17:40:16 +00:00
|
|
|
return "show help about `nix` or a particular subcommand";
|
2020-12-02 11:26:09 +00:00
|
|
|
}
|
|
|
|
|
2020-12-10 17:40:16 +00:00
|
|
|
std::string doc() override
|
2020-12-02 11:26:09 +00:00
|
|
|
{
|
2020-12-10 17:40:16 +00:00
|
|
|
return
|
|
|
|
#include "help.md"
|
|
|
|
;
|
2020-12-02 11:26:09 +00:00
|
|
|
}
|
|
|
|
|
2023-03-21 13:43:58 +00:00
|
|
|
Category category() override { return catHelp; }
|
|
|
|
|
2020-12-02 11:26:09 +00:00
|
|
|
void run() override
|
|
|
|
{
|
2021-09-13 12:41:28 +00:00
|
|
|
assert(parent);
|
|
|
|
MultiCommand * toplevel = parent;
|
|
|
|
while (toplevel->parent) toplevel = toplevel->parent;
|
2023-03-21 13:37:09 +00:00
|
|
|
showHelp(subcommand, getNixArgs(*this));
|
2020-12-02 11:26:09 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static auto rCmdHelp = registerCommand<CmdHelp>("help");
|
|
|
|
|
2023-03-21 13:37:09 +00:00
|
|
|
struct CmdHelpStores : Command
|
|
|
|
{
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "show help about store types and their settings";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string doc() override
|
|
|
|
{
|
|
|
|
return
|
|
|
|
#include "help-stores.md"
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2023-03-21 13:43:58 +00:00
|
|
|
Category category() override { return catHelp; }
|
|
|
|
|
2023-03-21 13:37:09 +00:00
|
|
|
void run() override
|
|
|
|
{
|
|
|
|
showHelp({"help-stores"}, getNixArgs(*this));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static auto rCmdHelpStores = registerCommand<CmdHelpStores>("help-stores");
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
void mainWrapped(int argc, char * * argv)
|
|
|
|
{
|
2021-01-13 23:05:04 +00:00
|
|
|
savedArgv = argv;
|
|
|
|
|
2017-08-29 11:21:07 +00:00
|
|
|
/* The chroot helper needs to be run before any threads have been
|
|
|
|
started. */
|
|
|
|
if (argc > 0 && argv[0] == chrootHelperName) {
|
|
|
|
chrootHelper(argc, argv);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
initNix();
|
|
|
|
initGC();
|
|
|
|
|
2021-11-08 21:00:45 +00:00
|
|
|
#if __linux__
|
|
|
|
if (getuid() == 0) {
|
2021-11-16 13:23:05 +00:00
|
|
|
try {
|
|
|
|
saveMountNamespace();
|
|
|
|
if (unshare(CLONE_NEWNS) == -1)
|
|
|
|
throw SysError("setting up a private mount namespace");
|
|
|
|
} catch (Error & e) { }
|
2021-11-08 21:00:45 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-05-11 10:55:31 +00:00
|
|
|
Finally f([] { logger->stop(); });
|
|
|
|
|
2018-01-31 15:14:47 +00:00
|
|
|
programPath = argv[0];
|
2019-12-05 18:11:09 +00:00
|
|
|
auto programName = std::string(baseNameOf(programPath));
|
2016-02-09 20:28:29 +00:00
|
|
|
|
2022-10-25 19:17:32 +00:00
|
|
|
if (argc > 1 && std::string_view(argv[1]) == "__build-remote") {
|
2022-06-22 20:43:53 +00:00
|
|
|
programName = "build-remote";
|
|
|
|
argv++; argc--;
|
|
|
|
}
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
{
|
|
|
|
auto legacy = (*RegisterLegacyCommand::commands)[programName];
|
|
|
|
if (legacy) return legacy(argc, argv);
|
|
|
|
}
|
|
|
|
|
2019-02-12 19:35:03 +00:00
|
|
|
evalSettings.pureEval = true;
|
2018-10-26 09:35:46 +00:00
|
|
|
|
2020-06-05 15:01:02 +00:00
|
|
|
setLogFormat("bar");
|
2022-01-14 17:07:47 +00:00
|
|
|
settings.verboseBuild = false;
|
|
|
|
if (isatty(STDERR_FILENO)) {
|
|
|
|
verbosity = lvlNotice;
|
|
|
|
} else {
|
|
|
|
verbosity = lvlInfo;
|
|
|
|
}
|
2020-06-05 15:01:02 +00:00
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
NixArgs args;
|
|
|
|
|
2023-03-21 11:58:14 +00:00
|
|
|
if (argc == 2 && std::string(argv[1]) == "__dump-cli") {
|
|
|
|
logger->cout(args.dumpCli());
|
2020-08-17 15:44:52 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-05-13 17:52:45 +00:00
|
|
|
if (argc == 2 && std::string(argv[1]) == "__dump-language") {
|
2023-03-17 14:33:48 +00:00
|
|
|
experimentalFeatureSettings.experimentalFeatures = {
|
|
|
|
Xp::Flakes,
|
|
|
|
Xp::FetchClosure,
|
|
|
|
};
|
2020-09-16 14:56:28 +00:00
|
|
|
evalSettings.pureEval = false;
|
2020-08-24 16:54:16 +00:00
|
|
|
EvalState state({}, openStore("dummy://"));
|
2020-08-24 12:49:30 +00:00
|
|
|
auto res = nlohmann::json::object();
|
2023-05-13 17:52:45 +00:00
|
|
|
res["builtins"] = ({
|
|
|
|
auto builtinsJson = nlohmann::json::object();
|
|
|
|
auto builtins = state.baseEnv.values[0]->attrs;
|
|
|
|
for (auto & builtin : *builtins) {
|
|
|
|
auto b = nlohmann::json::object();
|
|
|
|
if (!builtin.value->isPrimOp()) continue;
|
|
|
|
auto primOp = builtin.value->primOp;
|
|
|
|
if (!primOp->doc) continue;
|
|
|
|
b["arity"] = primOp->arity;
|
|
|
|
b["args"] = primOp->args;
|
|
|
|
b["doc"] = trim(stripIndentation(primOp->doc));
|
|
|
|
b["experimental-feature"] = primOp->experimentalFeature;
|
|
|
|
builtinsJson[state.symbols[builtin.name]] = std::move(b);
|
|
|
|
}
|
|
|
|
std::move(builtinsJson);
|
|
|
|
});
|
|
|
|
res["constants"] = ({
|
|
|
|
auto constantsJson = nlohmann::json::object();
|
|
|
|
for (auto & [name, info] : state.constantInfos) {
|
|
|
|
auto c = nlohmann::json::object();
|
|
|
|
if (!info.doc) continue;
|
|
|
|
c["doc"] = trim(stripIndentation(info.doc));
|
|
|
|
c["type"] = showType(info.type, false);
|
|
|
|
c["impure-only"] = info.impureOnly;
|
|
|
|
constantsJson[name] = std::move(c);
|
|
|
|
}
|
|
|
|
std::move(constantsJson);
|
|
|
|
});
|
2023-03-02 14:02:24 +00:00
|
|
|
logger->cout("%s", res);
|
2020-08-24 12:49:30 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-04-05 02:57:11 +00:00
|
|
|
if (argc == 2 && std::string(argv[1]) == "__dump-xp-features") {
|
|
|
|
logger->cout(documentExperimentalFeatures().dump());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-05-10 18:32:21 +00:00
|
|
|
Finally printCompletions([&]()
|
|
|
|
{
|
|
|
|
if (completions) {
|
2021-12-22 11:37:59 +00:00
|
|
|
switch (completionType) {
|
|
|
|
case ctNormal:
|
2023-03-02 14:02:24 +00:00
|
|
|
logger->cout("normal"); break;
|
2021-12-22 11:37:59 +00:00
|
|
|
case ctFilenames:
|
2023-03-02 14:02:24 +00:00
|
|
|
logger->cout("filenames"); break;
|
2021-12-22 11:37:59 +00:00
|
|
|
case ctAttrs:
|
2023-03-02 14:02:24 +00:00
|
|
|
logger->cout("attrs"); break;
|
2021-12-22 11:37:59 +00:00
|
|
|
}
|
2020-05-10 18:32:21 +00:00
|
|
|
for (auto & s : *completions)
|
2023-03-02 14:02:24 +00:00
|
|
|
logger->cout(s.completion + "\t" + trim(s.description));
|
2020-05-10 18:32:21 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
try {
|
|
|
|
args.parseCmdline(argvToStrings(argc, argv));
|
2023-01-17 00:13:31 +00:00
|
|
|
} catch (UsageError &) {
|
|
|
|
if (!args.helpRequested && !completions) throw;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (args.helpRequested) {
|
2021-01-25 13:38:15 +00:00
|
|
|
std::vector<std::string> subcommand;
|
|
|
|
MultiCommand * command = &args;
|
|
|
|
while (command) {
|
|
|
|
if (command && command->command) {
|
|
|
|
subcommand.push_back(command->command->first);
|
|
|
|
command = dynamic_cast<MultiCommand *>(&*command->command->second);
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
2021-09-13 12:41:28 +00:00
|
|
|
showHelp(subcommand, args);
|
2021-01-25 13:38:15 +00:00
|
|
|
return;
|
2020-05-10 18:32:21 +00:00
|
|
|
}
|
|
|
|
|
2022-06-20 02:15:38 +00:00
|
|
|
if (completions) {
|
|
|
|
args.completionHook();
|
|
|
|
return;
|
|
|
|
}
|
2019-10-16 15:45:09 +00:00
|
|
|
|
2021-02-17 16:11:14 +00:00
|
|
|
if (args.showVersion) {
|
|
|
|
printVersion(programName);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-01-25 13:38:15 +00:00
|
|
|
if (!args.command)
|
|
|
|
throw UsageError("no subcommand specified");
|
2016-02-09 20:28:29 +00:00
|
|
|
|
2023-01-17 04:01:18 +00:00
|
|
|
experimentalFeatureSettings.require(
|
|
|
|
args.command->second->experimentalFeature());
|
2020-05-07 14:46:25 +00:00
|
|
|
|
2019-06-17 07:57:22 +00:00
|
|
|
if (args.useNet && !haveInternet()) {
|
|
|
|
warn("you don't have Internet access; disabling some network-dependent features");
|
|
|
|
args.useNet = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!args.useNet) {
|
|
|
|
// FIXME: should check for command line overrides only.
|
2021-03-26 15:14:38 +00:00
|
|
|
if (!settings.useSubstitutes.overridden)
|
2019-06-17 07:57:22 +00:00
|
|
|
settings.useSubstitutes = false;
|
2021-03-26 15:14:38 +00:00
|
|
|
if (!settings.tarballTtl.overridden)
|
2019-06-17 07:57:22 +00:00
|
|
|
settings.tarballTtl = std::numeric_limits<unsigned int>::max();
|
2021-03-26 15:14:38 +00:00
|
|
|
if (!fileTransferSettings.tries.overridden)
|
2020-04-06 21:43:43 +00:00
|
|
|
fileTransferSettings.tries = 0;
|
2021-03-26 15:14:38 +00:00
|
|
|
if (!fileTransferSettings.connectTimeout.overridden)
|
2020-04-06 21:43:43 +00:00
|
|
|
fileTransferSettings.connectTimeout = 1;
|
2019-06-17 07:57:22 +00:00
|
|
|
}
|
|
|
|
|
2021-01-18 13:38:31 +00:00
|
|
|
if (args.refresh) {
|
2020-01-28 16:34:48 +00:00
|
|
|
settings.tarballTtl = 0;
|
2021-01-18 13:38:31 +00:00
|
|
|
settings.ttlNegativeNarInfoCache = 0;
|
|
|
|
settings.ttlPositiveNarInfoCache = 0;
|
|
|
|
}
|
2020-01-28 16:34:48 +00:00
|
|
|
|
2022-01-31 17:03:24 +00:00
|
|
|
if (args.command->second->forceImpureByDefault() && !evalSettings.pureEval.overridden) {
|
|
|
|
evalSettings.pureEval = false;
|
|
|
|
}
|
2020-05-05 13:18:23 +00:00
|
|
|
args.command->second->run();
|
2016-02-09 20:28:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char * * argv)
|
|
|
|
{
|
2021-02-18 18:22:37 +00:00
|
|
|
// Increase the default stack size for the evaluator and for
|
|
|
|
// libstdc++'s std::regex.
|
2021-04-07 11:40:13 +00:00
|
|
|
nix::setStackSize(64 * 1024 * 1024);
|
2021-02-18 18:22:37 +00:00
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
return nix::handleExceptions(argv[0], [&]() {
|
|
|
|
nix::mainWrapped(argc, argv);
|
|
|
|
});
|
|
|
|
}
|