2016-02-09 20:28:29 +00:00
|
|
|
#include "command.hh"
|
|
|
|
#include "store-api.hh"
|
2017-04-25 11:20:26 +00:00
|
|
|
#include "derivations.hh"
|
2019-11-08 14:13:32 +00:00
|
|
|
#include "nixexpr.hh"
|
2020-03-30 17:14:17 +00:00
|
|
|
#include "profiles.hh"
|
|
|
|
|
2020-06-17 02:19:15 +00:00
|
|
|
extern char * * environ __attribute__((weak));
|
2016-02-09 20:28:29 +00:00
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
2019-06-18 14:01:35 +00:00
|
|
|
Commands * RegisterCommand::commands = nullptr;
|
2016-02-09 20:28:29 +00:00
|
|
|
|
2016-03-21 17:03:36 +00:00
|
|
|
StoreCommand::StoreCommand()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-04-25 09:20:37 +00:00
|
|
|
ref<Store> StoreCommand::getStore()
|
|
|
|
{
|
|
|
|
if (!_store)
|
|
|
|
_store = createStore();
|
|
|
|
return ref<Store>(_store);
|
|
|
|
}
|
|
|
|
|
2017-03-16 13:25:54 +00:00
|
|
|
ref<Store> StoreCommand::createStore()
|
|
|
|
{
|
2017-10-23 17:34:49 +00:00
|
|
|
return openStore();
|
2017-03-16 13:25:54 +00:00
|
|
|
}
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
void StoreCommand::run()
|
|
|
|
{
|
2017-09-08 12:46:55 +00:00
|
|
|
run(getStore());
|
2016-02-09 20:28:29 +00:00
|
|
|
}
|
|
|
|
|
2017-09-27 16:28:54 +00:00
|
|
|
StorePathsCommand::StorePathsCommand(bool recursive)
|
|
|
|
: recursive(recursive)
|
2016-03-29 12:29:50 +00:00
|
|
|
{
|
2017-09-27 16:28:54 +00:00
|
|
|
if (recursive)
|
2020-05-04 20:40:19 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "no-recursive",
|
|
|
|
.description = "apply operation to specified paths only",
|
|
|
|
.handler = {&this->recursive, false},
|
|
|
|
});
|
2017-09-27 16:28:54 +00:00
|
|
|
else
|
2020-05-04 20:40:19 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "recursive",
|
|
|
|
.shortName = 'r',
|
|
|
|
.description = "apply operation to closure of the specified paths",
|
|
|
|
.handler = {&this->recursive, true},
|
|
|
|
});
|
2017-09-27 16:28:54 +00:00
|
|
|
|
2016-04-14 19:14:29 +00:00
|
|
|
mkFlag(0, "all", "apply operation to the entire store", &all);
|
2016-03-29 12:29:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void StorePathsCommand::run(ref<Store> store)
|
|
|
|
{
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePaths storePaths;
|
2017-04-25 11:20:26 +00:00
|
|
|
|
2016-04-14 19:14:29 +00:00
|
|
|
if (all) {
|
2017-04-25 11:20:26 +00:00
|
|
|
if (installables.size())
|
2017-07-30 11:27:57 +00:00
|
|
|
throw UsageError("'--all' does not expect arguments");
|
2016-04-14 19:14:29 +00:00
|
|
|
for (auto & p : store->queryAllValidPaths())
|
2020-06-16 20:20:18 +00:00
|
|
|
storePaths.push_back(p);
|
2016-04-14 19:14:29 +00:00
|
|
|
}
|
2016-03-29 12:29:50 +00:00
|
|
|
|
2016-04-14 19:14:29 +00:00
|
|
|
else {
|
2018-03-29 22:56:13 +00:00
|
|
|
for (auto & p : toStorePaths(store, realiseMode, installables))
|
2020-06-16 20:20:18 +00:00
|
|
|
storePaths.push_back(p);
|
2016-04-14 19:14:29 +00:00
|
|
|
|
|
|
|
if (recursive) {
|
2019-12-05 18:11:09 +00:00
|
|
|
StorePathSet closure;
|
2020-06-16 20:20:18 +00:00
|
|
|
store->computeFSClosure(StorePathSet(storePaths.begin(), storePaths.end()), closure, false, false);
|
2019-12-05 18:11:09 +00:00
|
|
|
storePaths.clear();
|
|
|
|
for (auto & p : closure)
|
2020-06-16 20:20:18 +00:00
|
|
|
storePaths.push_back(p);
|
2016-04-14 19:14:29 +00:00
|
|
|
}
|
2016-03-29 12:29:50 +00:00
|
|
|
}
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
run(store, std::move(storePaths));
|
2016-03-29 12:29:50 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 12:16:26 +00:00
|
|
|
void StorePathCommand::run(ref<Store> store)
|
|
|
|
{
|
2020-07-15 18:05:42 +00:00
|
|
|
auto storePaths = toStorePaths(store, Realise::Nothing, installables);
|
2017-05-04 12:16:26 +00:00
|
|
|
|
|
|
|
if (storePaths.size() != 1)
|
|
|
|
throw UsageError("this command requires exactly one store path");
|
|
|
|
|
|
|
|
run(store, *storePaths.begin());
|
|
|
|
}
|
|
|
|
|
2019-11-08 14:13:32 +00:00
|
|
|
Strings editorFor(const Pos & pos)
|
|
|
|
{
|
2019-11-22 15:06:44 +00:00
|
|
|
auto editor = getEnv("EDITOR").value_or("cat");
|
2019-11-08 14:13:32 +00:00
|
|
|
auto args = tokenizeString<Strings>(editor);
|
|
|
|
if (pos.line > 0 && (
|
|
|
|
editor.find("emacs") != std::string::npos ||
|
|
|
|
editor.find("nano") != std::string::npos ||
|
|
|
|
editor.find("vim") != std::string::npos))
|
|
|
|
args.push_back(fmt("+%d", pos.line));
|
|
|
|
args.push_back(pos.file);
|
|
|
|
return args;
|
|
|
|
}
|
|
|
|
|
2020-03-30 17:14:17 +00:00
|
|
|
MixProfile::MixProfile()
|
|
|
|
{
|
2020-05-04 20:40:19 +00:00
|
|
|
addFlag({
|
|
|
|
.longName = "profile",
|
|
|
|
.description = "profile to update",
|
|
|
|
.labels = {"path"},
|
|
|
|
.handler = {&profile},
|
2020-05-10 19:35:07 +00:00
|
|
|
.completer = completePath
|
2020-05-04 20:40:19 +00:00
|
|
|
});
|
2020-03-30 17:14:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MixProfile::updateProfile(const StorePath & storePath)
|
|
|
|
{
|
|
|
|
if (!profile) return;
|
|
|
|
auto store = getStore().dynamic_pointer_cast<LocalFSStore>();
|
|
|
|
if (!store) throw Error("'--profile' is not supported for this Nix store");
|
|
|
|
auto profile2 = absPath(*profile);
|
|
|
|
switchLink(profile2,
|
|
|
|
createGeneration(
|
|
|
|
ref<LocalFSStore>(store),
|
|
|
|
profile2, store->printStorePath(storePath)));
|
|
|
|
}
|
|
|
|
|
|
|
|
void MixProfile::updateProfile(const Buildables & buildables)
|
|
|
|
{
|
|
|
|
if (!profile) return;
|
|
|
|
|
|
|
|
std::optional<StorePath> result;
|
|
|
|
|
|
|
|
for (auto & buildable : buildables) {
|
|
|
|
for (auto & output : buildable.outputs) {
|
|
|
|
if (result)
|
|
|
|
throw Error("'--profile' requires that the arguments produce a single store path, but there are multiple");
|
2020-06-16 20:20:18 +00:00
|
|
|
result = output.second;
|
2020-03-30 17:14:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!result)
|
|
|
|
throw Error("'--profile' requires that the arguments produce a single store path, but there are none");
|
|
|
|
|
|
|
|
updateProfile(*result);
|
|
|
|
}
|
|
|
|
|
|
|
|
MixDefaultProfile::MixDefaultProfile()
|
|
|
|
{
|
|
|
|
profile = getDefaultProfile();
|
|
|
|
}
|
|
|
|
|
2020-05-04 20:40:19 +00:00
|
|
|
MixEnvironment::MixEnvironment() : ignoreEnvironment(false)
|
|
|
|
{
|
|
|
|
addFlag({
|
|
|
|
.longName = "ignore-environment",
|
|
|
|
.shortName = 'i',
|
|
|
|
.description = "clear the entire environment (except those specified with --keep)",
|
|
|
|
.handler = {&ignoreEnvironment, true},
|
|
|
|
});
|
|
|
|
|
|
|
|
addFlag({
|
|
|
|
.longName = "keep",
|
|
|
|
.shortName = 'k',
|
|
|
|
.description = "keep specified environment variable",
|
|
|
|
.labels = {"name"},
|
|
|
|
.handler = {[&](std::string s) { keep.insert(s); }},
|
|
|
|
});
|
|
|
|
|
|
|
|
addFlag({
|
|
|
|
.longName = "unset",
|
|
|
|
.shortName = 'u',
|
|
|
|
.description = "unset specified environment variable",
|
|
|
|
.labels = {"name"},
|
|
|
|
.handler = {[&](std::string s) { unset.insert(s); }},
|
|
|
|
});
|
2020-03-30 17:14:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MixEnvironment::setEnviron() {
|
|
|
|
if (ignoreEnvironment) {
|
|
|
|
if (!unset.empty())
|
|
|
|
throw UsageError("--unset does not make sense with --ignore-environment");
|
|
|
|
|
|
|
|
for (const auto & var : keep) {
|
|
|
|
auto val = getenv(var.c_str());
|
|
|
|
if (val) stringsEnv.emplace_back(fmt("%s=%s", var.c_str(), val));
|
|
|
|
}
|
|
|
|
|
|
|
|
vectorEnv = stringsToCharPtrs(stringsEnv);
|
|
|
|
environ = vectorEnv.data();
|
|
|
|
} else {
|
|
|
|
if (!keep.empty())
|
|
|
|
throw UsageError("--keep does not make sense without --ignore-environment");
|
|
|
|
|
|
|
|
for (const auto & var : unset)
|
|
|
|
unsetenv(var.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-09 20:28:29 +00:00
|
|
|
}
|