aboutsummaryrefslogtreecommitdiff
path: root/src/legacy/nix-store.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/legacy/nix-store.cc')
-rw-r--r--src/legacy/nix-store.cc1183
1 files changed, 1183 insertions, 0 deletions
diff --git a/src/legacy/nix-store.cc b/src/legacy/nix-store.cc
new file mode 100644
index 000000000..e42aa4065
--- /dev/null
+++ b/src/legacy/nix-store.cc
@@ -0,0 +1,1183 @@
+#include "archive.hh"
+#include "derivations.hh"
+#include "dotgraph.hh"
+#include "exit.hh"
+#include "globals.hh"
+#include "build-result.hh"
+#include "store-cast.hh"
+#include "gc-store.hh"
+#include "log-store.hh"
+#include "local-store.hh"
+#include "monitor-fd.hh"
+#include "serve-protocol.hh"
+#include "serve-protocol-impl.hh"
+#include "shared.hh"
+#include "graphml.hh"
+#include "legacy.hh"
+#include "path-with-outputs.hh"
+#include "nix-store.hh"
+
+#include <iostream>
+#include <algorithm>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+namespace nix {
+
+
+using std::cin;
+using std::cout;
+
+
+typedef void (* Operation) (Strings opFlags, Strings opArgs);
+
+
+static Path gcRoot;
+static int rootNr = 0;
+static bool noOutput = false;
+static std::shared_ptr<Store> store;
+
+
+ref<LocalStore> ensureLocalStore()
+{
+ auto store2 = std::dynamic_pointer_cast<LocalStore>(store);
+ if (!store2) throw Error("you don't have sufficient rights to use this command");
+ return ref<LocalStore>(store2);
+}
+
+
+static StorePath useDeriver(const StorePath & path)
+{
+ if (path.isDerivation()) return path;
+ auto info = store->queryPathInfo(path);
+ if (!info->deriver)
+ throw Error("deriver of path '%s' is not known", store->printStorePath(path));
+ return *info->deriver;
+}
+
+
+/* Realise the given path. For a derivation that means build it; for
+ other paths it means ensure their validity. */
+static PathSet realisePath(StorePathWithOutputs path, bool build = true)
+{
+ auto store2 = std::dynamic_pointer_cast<LocalFSStore>(store);
+
+ if (path.path.isDerivation()) {
+ if (build) store->buildPaths({path.toDerivedPath()});
+ auto outputPaths = store->queryDerivationOutputMap(path.path);
+ Derivation drv = store->derivationFromPath(path.path);
+ rootNr++;
+
+ /* FIXME: Encode this empty special case explicitly in the type. */
+ if (path.outputs.empty())
+ for (auto & i : drv.outputs) path.outputs.insert(i.first);
+
+ PathSet outputs;
+ for (auto & j : path.outputs) {
+ /* Match outputs of a store path with outputs of the derivation that produces it. */
+ DerivationOutputs::iterator i = drv.outputs.find(j);
+ if (i == drv.outputs.end())
+ throw Error("derivation '%s' does not have an output named '%s'",
+ store2->printStorePath(path.path), j);
+ auto outPath = outputPaths.at(i->first);
+ auto retPath = store->printStorePath(outPath);
+ if (store2) {
+ if (gcRoot == "")
+ printGCWarning();
+ else {
+ Path rootName = gcRoot;
+ if (rootNr > 1) rootName += "-" + std::to_string(rootNr);
+ if (i->first != "out") rootName += "-" + i->first;
+ retPath = store2->addPermRoot(outPath, rootName);
+ }
+ }
+ outputs.insert(retPath);
+ }
+ return outputs;
+ }
+
+ else {
+ if (build) store->ensurePath(path.path);
+ else if (!store->isValidPath(path.path))
+ throw Error("path '%s' does not exist and cannot be created", store->printStorePath(path.path));
+ if (store2) {
+ if (gcRoot == "")
+ printGCWarning();
+ else {
+ Path rootName = gcRoot;
+ rootNr++;
+ if (rootNr > 1) rootName += "-" + std::to_string(rootNr);
+ return {store2->addPermRoot(path.path, rootName)};
+ }
+ }
+ return {store->printStorePath(path.path)};
+ }
+}
+
+
+/* Realise the given paths. */
+static void opRealise(Strings opFlags, Strings opArgs)
+{
+ bool dryRun = false;
+ BuildMode buildMode = bmNormal;
+ bool ignoreUnknown = false;
+
+ for (auto & i : opFlags)
+ if (i == "--dry-run") dryRun = true;
+ else if (i == "--repair") buildMode = bmRepair;
+ else if (i == "--check") buildMode = bmCheck;
+ else if (i == "--ignore-unknown") ignoreUnknown = true;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ std::vector<StorePathWithOutputs> paths;
+ for (auto & i : opArgs)
+ paths.push_back(followLinksToStorePathWithOutputs(*store, i));
+
+ uint64_t downloadSize, narSize;
+ StorePathSet willBuild, willSubstitute, unknown;
+ store->queryMissing(
+ toDerivedPaths(paths),
+ willBuild, willSubstitute, unknown, downloadSize, narSize);
+
+ /* Filter out unknown paths from `paths`. */
+ if (ignoreUnknown) {
+ std::vector<StorePathWithOutputs> paths2;
+ for (auto & i : paths)
+ if (!unknown.count(i.path)) paths2.push_back(i);
+ paths = std::move(paths2);
+ unknown = StorePathSet();
+ }
+
+ if (settings.printMissing)
+ printMissing(ref<Store>(store), willBuild, willSubstitute, unknown, downloadSize, narSize);
+
+ if (dryRun) return;
+
+ /* Build all paths at the same time to exploit parallelism. */
+ store->buildPaths(toDerivedPaths(paths), buildMode);
+
+ if (!ignoreUnknown)
+ for (auto & i : paths) {
+ auto paths2 = realisePath(i, false);
+ if (!noOutput)
+ for (auto & j : paths2)
+ cout << fmt("%1%\n", j);
+ }
+}
+
+
+/* Add files to the Nix store and print the resulting paths. */
+static void opAdd(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+
+ for (auto & i : opArgs)
+ cout << fmt("%s\n", store->printStorePath(store->addToStore(std::string(baseNameOf(i)), i)));
+}
+
+
+/* Preload the output of a fixed-output derivation into the Nix
+ store. */
+static void opAddFixed(Strings opFlags, Strings opArgs)
+{
+ auto method = FileIngestionMethod::Flat;
+
+ for (auto & i : opFlags)
+ if (i == "--recursive") method = FileIngestionMethod::Recursive;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ if (opArgs.empty())
+ throw UsageError("first argument must be hash algorithm");
+
+ HashType hashAlgo = parseHashType(opArgs.front());
+ opArgs.pop_front();
+
+ for (auto & i : opArgs)
+ std::cout << fmt("%s\n", store->printStorePath(store->addToStoreSlow(baseNameOf(i), i, method, hashAlgo).path));
+}
+
+
+/* Hack to support caching in `nix-prefetch-url'. */
+static void opPrintFixedPath(Strings opFlags, Strings opArgs)
+{
+ auto method = FileIngestionMethod::Flat;
+
+ for (auto i : opFlags)
+ if (i == "--recursive") method = FileIngestionMethod::Recursive;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ if (opArgs.size() != 3)
+ throw UsageError("'--print-fixed-path' requires three arguments");
+
+ Strings::iterator i = opArgs.begin();
+ HashType hashAlgo = parseHashType(*i++);
+ std::string hash = *i++;
+ std::string name = *i++;
+
+ cout << fmt("%s\n", store->printStorePath(store->makeFixedOutputPath(name, FixedOutputInfo {
+ .method = method,
+ .hash = Hash::parseAny(hash, hashAlgo),
+ .references = {},
+ })));
+}
+
+
+static StorePathSet maybeUseOutputs(const StorePath & storePath, bool useOutput, bool forceRealise)
+{
+ if (forceRealise) realisePath({storePath});
+ if (useOutput && storePath.isDerivation()) {
+ auto drv = store->derivationFromPath(storePath);
+ StorePathSet outputs;
+ if (forceRealise)
+ return store->queryDerivationOutputs(storePath);
+ for (auto & i : drv.outputsAndOptPaths(*store)) {
+ if (!i.second.second)
+ throw UsageError("Cannot use output path of floating content-addressed derivation until we know what it is (e.g. by building it)");
+ outputs.insert(*i.second.second);
+ }
+ return outputs;
+ }
+ else return {storePath};
+}
+
+
+/* Some code to print a tree representation of a derivation dependency
+ graph. Topological sorting is used to keep the tree relatively
+ flat. */
+static void printTree(const StorePath & path,
+ const std::string & firstPad, const std::string & tailPad, StorePathSet & done)
+{
+ if (!done.insert(path).second) {
+ cout << fmt("%s%s [...]\n", firstPad, store->printStorePath(path));
+ return;
+ }
+
+ cout << fmt("%s%s\n", firstPad, store->printStorePath(path));
+
+ auto info = store->queryPathInfo(path);
+
+ /* Topologically sort under the relation A < B iff A \in
+ closure(B). That is, if derivation A is an (possibly indirect)
+ input of B, then A is printed first. This has the effect of
+ flattening the tree, preventing deeply nested structures. */
+ auto sorted = store->topoSortPaths(info->references);
+ reverse(sorted.begin(), sorted.end());
+
+ for (const auto &[n, i] : enumerate(sorted)) {
+ bool last = n + 1 == sorted.size();
+ printTree(i,
+ tailPad + (last ? treeLast : treeConn),
+ tailPad + (last ? treeNull : treeLine),
+ done);
+ }
+}
+
+
+/* Perform various sorts of queries. */
+static void opQuery(Strings opFlags, Strings opArgs)
+{
+ enum QueryType
+ { qOutputs, qRequisites, qReferences, qReferrers
+ , qReferrersClosure, qDeriver, qValidDerivers, qBinding, qHash, qSize
+ , qTree, qGraph, qGraphML, qResolve, qRoots };
+ std::optional<QueryType> query;
+ bool useOutput = false;
+ bool includeOutputs = false;
+ bool forceRealise = false;
+ std::string bindingName;
+
+ for (auto & i : opFlags) {
+ std::optional<QueryType> prev = query;
+ if (i == "--outputs") query = qOutputs;
+ else if (i == "--requisites" || i == "-R") query = qRequisites;
+ else if (i == "--references") query = qReferences;
+ else if (i == "--referrers" || i == "--referers") query = qReferrers;
+ else if (i == "--referrers-closure" || i == "--referers-closure") query = qReferrersClosure;
+ else if (i == "--deriver" || i == "-d") query = qDeriver;
+ else if (i == "--valid-derivers") query = qValidDerivers;
+ else if (i == "--binding" || i == "-b") {
+ if (opArgs.size() == 0)
+ throw UsageError("expected binding name");
+ bindingName = opArgs.front();
+ opArgs.pop_front();
+ query = qBinding;
+ }
+ else if (i == "--hash") query = qHash;
+ else if (i == "--size") query = qSize;
+ else if (i == "--tree") query = qTree;
+ else if (i == "--graph") query = qGraph;
+ else if (i == "--graphml") query = qGraphML;
+ else if (i == "--resolve") query = qResolve;
+ else if (i == "--roots") query = qRoots;
+ else if (i == "--use-output" || i == "-u") useOutput = true;
+ else if (i == "--force-realise" || i == "--force-realize" || i == "-f") forceRealise = true;
+ else if (i == "--include-outputs") includeOutputs = true;
+ else throw UsageError("unknown flag '%1%'", i);
+ if (prev && prev != query)
+ throw UsageError("query type '%1%' conflicts with earlier flag", i);
+ }
+
+ if (!query) query = qOutputs;
+
+ RunPager pager;
+
+ switch (*query) {
+
+ case qOutputs: {
+ for (auto & i : opArgs) {
+ auto outputs = maybeUseOutputs(store->followLinksToStorePath(i), true, forceRealise);
+ for (auto & outputPath : outputs)
+ cout << fmt("%1%\n", store->printStorePath(outputPath));
+ }
+ break;
+ }
+
+ case qRequisites:
+ case qReferences:
+ case qReferrers:
+ case qReferrersClosure: {
+ StorePathSet paths;
+ for (auto & i : opArgs) {
+ auto ps = maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise);
+ for (auto & j : ps) {
+ if (query == qRequisites) store->computeFSClosure(j, paths, false, includeOutputs);
+ else if (query == qReferences) {
+ for (auto & p : store->queryPathInfo(j)->references)
+ paths.insert(p);
+ }
+ else if (query == qReferrers) {
+ StorePathSet tmp;
+ store->queryReferrers(j, tmp);
+ for (auto & i : tmp)
+ paths.insert(i);
+ }
+ else if (query == qReferrersClosure) store->computeFSClosure(j, paths, true);
+ }
+ }
+ auto sorted = store->topoSortPaths(paths);
+ for (StorePaths::reverse_iterator i = sorted.rbegin();
+ i != sorted.rend(); ++i)
+ cout << fmt("%s\n", store->printStorePath(*i));
+ break;
+ }
+
+ case qDeriver:
+ for (auto & i : opArgs) {
+ auto info = store->queryPathInfo(store->followLinksToStorePath(i));
+ cout << fmt("%s\n", info->deriver ? store->printStorePath(*info->deriver) : "unknown-deriver");
+ }
+ break;
+
+ case qValidDerivers: {
+ StorePathSet result;
+ for (auto & i : opArgs) {
+ auto derivers = store->queryValidDerivers(store->followLinksToStorePath(i));
+ for (const auto &i: derivers) {
+ result.insert(i);
+ }
+ }
+ auto sorted = store->topoSortPaths(result);
+ for (StorePaths::reverse_iterator i = sorted.rbegin();
+ i != sorted.rend(); ++i)
+ cout << fmt("%s\n", store->printStorePath(*i));
+ break;
+ }
+
+ case qBinding:
+ for (auto & i : opArgs) {
+ auto path = useDeriver(store->followLinksToStorePath(i));
+ Derivation drv = store->derivationFromPath(path);
+ StringPairs::iterator j = drv.env.find(bindingName);
+ if (j == drv.env.end())
+ throw Error("derivation '%s' has no environment binding named '%s'",
+ store->printStorePath(path), bindingName);
+ cout << fmt("%s\n", j->second);
+ }
+ break;
+
+ case qHash:
+ case qSize:
+ for (auto & i : opArgs) {
+ for (auto & j : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise)) {
+ auto info = store->queryPathInfo(j);
+ if (query == qHash) {
+ assert(info->narHash.type == HashType::SHA256);
+ cout << fmt("%s\n", info->narHash.to_string(Base::Base32, true));
+ } else if (query == qSize)
+ cout << fmt("%d\n", info->narSize);
+ }
+ }
+ break;
+
+ case qTree: {
+ StorePathSet done;
+ for (auto & i : opArgs)
+ printTree(store->followLinksToStorePath(i), "", "", done);
+ break;
+ }
+
+ case qGraph: {
+ StorePathSet roots;
+ for (auto & i : opArgs)
+ for (auto & j : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise))
+ roots.insert(j);
+ printDotGraph(ref<Store>(store), std::move(roots));
+ break;
+ }
+
+ case qGraphML: {
+ StorePathSet roots;
+ for (auto & i : opArgs)
+ for (auto & j : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise))
+ roots.insert(j);
+ printGraphML(ref<Store>(store), std::move(roots));
+ break;
+ }
+
+ case qResolve: {
+ for (auto & i : opArgs)
+ cout << fmt("%s\n", store->printStorePath(store->followLinksToStorePath(i)));
+ break;
+ }
+
+ case qRoots: {
+ StorePathSet args;
+ for (auto & i : opArgs)
+ for (auto & p : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise))
+ args.insert(p);
+
+ StorePathSet referrers;
+ store->computeFSClosure(
+ args, referrers, true, settings.gcKeepOutputs, settings.gcKeepDerivations);
+
+ auto & gcStore = require<GcStore>(*store);
+ Roots roots = gcStore.findRoots(false);
+ for (auto & [target, links] : roots)
+ if (referrers.find(target) != referrers.end())
+ for (auto & link : links)
+ cout << fmt("%1% -> %2%\n", link, gcStore.printStorePath(target));
+ break;
+ }
+
+ default:
+ abort();
+ }
+}
+
+
+static void opPrintEnv(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+ if (opArgs.size() != 1) throw UsageError("'--print-env' requires one derivation store path");
+
+ Path drvPath = opArgs.front();
+ Derivation drv = store->derivationFromPath(store->parseStorePath(drvPath));
+
+ /* Print each environment variable in the derivation in a format
+ * that can be sourced by the shell. */
+ for (auto & i : drv.env)
+ logger->cout("export %1%; %1%=%2%\n", i.first, shellEscape(i.second));
+
+ /* Also output the arguments. This doesn't preserve whitespace in
+ arguments. */
+ cout << "export _args; _args='";
+ bool first = true;
+ for (auto & i : drv.args) {
+ if (!first) cout << ' ';
+ first = false;
+ cout << shellEscape(i);
+ }
+ cout << "'\n";
+}
+
+
+static void opReadLog(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+
+ auto & logStore = require<LogStore>(*store);
+
+ RunPager pager;
+
+ for (auto & i : opArgs) {
+ auto path = logStore.followLinksToStorePath(i);
+ auto log = logStore.getBuildLog(path);
+ if (!log)
+ throw Error("build log of derivation '%s' is not available", logStore.printStorePath(path));
+ std::cout << *log;
+ }
+}
+
+
+static void opDumpDB(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+ if (!opArgs.empty()) {
+ for (auto & i : opArgs)
+ cout << store->makeValidityRegistration({store->followLinksToStorePath(i)}, true, true);
+ } else {
+ for (auto & i : store->queryAllValidPaths())
+ cout << store->makeValidityRegistration({i}, true, true);
+ }
+}
+
+
+static void registerValidity(bool reregister, bool hashGiven, bool canonicalise)
+{
+ ValidPathInfos infos;
+
+ while (1) {
+ // We use a dummy value because we'll set it below. FIXME be correct by
+ // construction and avoid dummy value.
+ auto hashResultOpt = !hashGiven ? std::optional<HashResult> { {Hash::dummy, -1} } : std::nullopt;
+ auto info = decodeValidPathInfo(*store, cin, hashResultOpt);
+ if (!info) break;
+ if (!store->isValidPath(info->path) || reregister) {
+ /* !!! races */
+ if (canonicalise)
+ canonicalisePathMetaData(store->printStorePath(info->path), {});
+ if (!hashGiven) {
+ HashResult hash = hashPath(HashType::SHA256, store->printStorePath(info->path));
+ info->narHash = hash.first;
+ info->narSize = hash.second;
+ }
+ infos.insert_or_assign(info->path, *info);
+ }
+ }
+
+ ensureLocalStore()->registerValidPaths(infos);
+}
+
+
+static void opLoadDB(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+ if (!opArgs.empty())
+ throw UsageError("no arguments expected");
+ registerValidity(true, true, false);
+}
+
+
+static void opRegisterValidity(Strings opFlags, Strings opArgs)
+{
+ bool reregister = false; // !!! maybe this should be the default
+ bool hashGiven = false;
+
+ for (auto & i : opFlags)
+ if (i == "--reregister") reregister = true;
+ else if (i == "--hash-given") hashGiven = true;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+ registerValidity(reregister, hashGiven, true);
+}
+
+
+static void opCheckValidity(Strings opFlags, Strings opArgs)
+{
+ bool printInvalid = false;
+
+ for (auto & i : opFlags)
+ if (i == "--print-invalid") printInvalid = true;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ for (auto & i : opArgs) {
+ auto path = store->followLinksToStorePath(i);
+ if (!store->isValidPath(path)) {
+ if (printInvalid)
+ cout << fmt("%s\n", store->printStorePath(path));
+ else
+ throw Error("path '%s' is not valid", store->printStorePath(path));
+ }
+ }
+}
+
+
+static void opGC(Strings opFlags, Strings opArgs)
+{
+ bool printRoots = false;
+ GCOptions options;
+ options.action = GCOptions::gcDeleteDead;
+
+ GCResults results;
+
+ /* Do what? */
+ for (auto i = opFlags.begin(); i != opFlags.end(); ++i)
+ if (*i == "--print-roots") printRoots = true;
+ else if (*i == "--print-live") options.action = GCOptions::gcReturnLive;
+ else if (*i == "--print-dead") options.action = GCOptions::gcReturnDead;
+ else if (*i == "--max-freed")
+ options.maxFreed = std::max(getIntArg<int64_t>(*i, i, opFlags.end(), true), (int64_t) 0);
+ else throw UsageError("bad sub-operation '%1%' in GC", *i);
+
+ if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+ auto & gcStore = require<GcStore>(*store);
+
+ if (printRoots) {
+ Roots roots = gcStore.findRoots(false);
+ std::set<std::pair<Path, StorePath>> roots2;
+ // Transpose and sort the roots.
+ for (auto & [target, links] : roots)
+ for (auto & link : links)
+ roots2.emplace(link, target);
+ for (auto & [link, target] : roots2)
+ std::cout << link << " -> " << gcStore.printStorePath(target) << "\n";
+ }
+
+ else {
+ PrintFreed freed(options.action == GCOptions::gcDeleteDead, results);
+ gcStore.collectGarbage(options, results);
+
+ if (options.action != GCOptions::gcDeleteDead)
+ for (auto & i : results.paths)
+ cout << i << std::endl;
+ }
+}
+
+
+/* Remove paths from the Nix store if possible (i.e., if they do not
+ have any remaining referrers and are not reachable from any GC
+ roots). */
+static void opDelete(Strings opFlags, Strings opArgs)
+{
+ GCOptions options;
+ options.action = GCOptions::gcDeleteSpecific;
+
+ for (auto & i : opFlags)
+ if (i == "--ignore-liveness") options.ignoreLiveness = true;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ for (auto & i : opArgs)
+ options.pathsToDelete.insert(store->followLinksToStorePath(i));
+
+ auto & gcStore = require<GcStore>(*store);
+
+ GCResults results;
+ PrintFreed freed(true, results);
+ gcStore.collectGarbage(options, results);
+}
+
+
+/* Dump a path as a Nix archive. The archive is written to stdout */
+static void opDump(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+ if (opArgs.size() != 1) throw UsageError("only one argument allowed");
+
+ FdSink sink(STDOUT_FILENO);
+ std::string path = *opArgs.begin();
+ sink << dumpPath(path);
+ sink.flush();
+}
+
+
+/* Restore a value from a Nix archive. The archive is read from stdin. */
+static void opRestore(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+ if (opArgs.size() != 1) throw UsageError("only one argument allowed");
+
+ FdSource source(STDIN_FILENO);
+ restorePath(*opArgs.begin(), source);
+}
+
+
+static void opExport(Strings opFlags, Strings opArgs)
+{
+ for (auto & i : opFlags)
+ throw UsageError("unknown flag '%1%'", i);
+
+ StorePathSet paths;
+
+ for (auto & i : opArgs)
+ paths.insert(store->followLinksToStorePath(i));
+
+ FdSink sink(STDOUT_FILENO);
+ store->exportPaths(paths, sink);
+ sink.flush();
+}
+
+
+static void opImport(Strings opFlags, Strings opArgs)
+{
+ for (auto & i : opFlags)
+ throw UsageError("unknown flag '%1%'", i);
+
+ if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+ FdSource source(STDIN_FILENO);
+ auto paths = store->importPaths(source, NoCheckSigs);
+
+ for (auto & i : paths)
+ cout << fmt("%s\n", store->printStorePath(i)) << std::flush;
+}
+
+
+/* Initialise the Nix databases. */
+static void opInit(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty()) throw UsageError("unknown flag");
+ if (!opArgs.empty())
+ throw UsageError("no arguments expected");
+ /* Doesn't do anything right now; database tables are initialised
+ automatically. */
+}
+
+
+/* Verify the consistency of the Nix environment. */
+static void opVerify(Strings opFlags, Strings opArgs)
+{
+ if (!opArgs.empty())
+ throw UsageError("no arguments expected");
+
+ bool checkContents = false;
+ RepairFlag repair = NoRepair;
+
+ for (auto & i : opFlags)
+ if (i == "--check-contents") checkContents = true;
+ else if (i == "--repair") repair = Repair;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ if (store->verifyStore(checkContents, repair)) {
+ warn("not all store errors were fixed");
+ throw Exit(1);
+ }
+}
+
+
+/* Verify whether the contents of the given store path have not changed. */
+static void opVerifyPath(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty())
+ throw UsageError("no flags expected");
+
+ int status = 0;
+
+ for (auto & i : opArgs) {
+ auto path = store->followLinksToStorePath(i);
+ printMsg(lvlTalkative, "checking path '%s'...", store->printStorePath(path));
+ auto info = store->queryPathInfo(path);
+ HashSink sink(info->narHash.type);
+ sink << store->narFromPath(path);
+ auto current = sink.finish();
+ if (current.first != info->narHash) {
+ printError("path '%s' was modified! expected hash '%s', got '%s'",
+ store->printStorePath(path),
+ info->narHash.to_string(Base::Base32, true),
+ current.first.to_string(Base::Base32, true));
+ status = 1;
+ }
+ }
+
+ throw Exit(status);
+}
+
+
+/* Repair the contents of the given path by redownloading it using a
+ substituter (if available). */
+static void opRepairPath(Strings opFlags, Strings opArgs)
+{
+ if (!opFlags.empty())
+ throw UsageError("no flags expected");
+
+ for (auto & i : opArgs)
+ store->repairPath(store->followLinksToStorePath(i));
+}
+
+/* Optimise the disk space usage of the Nix store by hard-linking
+ files with the same contents. */
+static void opOptimise(Strings opFlags, Strings opArgs)
+{
+ if (!opArgs.empty() || !opFlags.empty())
+ throw UsageError("no arguments expected");
+
+ store->optimiseStore();
+}
+
+/* Serve the nix store in a way usable by a restricted ssh user. */
+static void opServe(Strings opFlags, Strings opArgs)
+{
+ bool writeAllowed = false;
+ for (auto & i : opFlags)
+ if (i == "--write") writeAllowed = true;
+ else throw UsageError("unknown flag '%1%'", i);
+
+ if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+ FdSource in(STDIN_FILENO);
+ FdSink out(STDOUT_FILENO);
+
+ /* Exchange the greeting. */
+ unsigned int magic = readInt(in);
+ if (magic != SERVE_MAGIC_1) throw Error("protocol mismatch");
+ out << SERVE_MAGIC_2 << SERVE_PROTOCOL_VERSION;
+ out.flush();
+ ServeProto::Version clientVersion = readInt(in);
+
+ ServeProto::ReadConn rconn {
+ .from = in,
+ .version = clientVersion,
+ };
+ ServeProto::WriteConn wconn {
+ .version = clientVersion,
+ };
+
+ auto getBuildSettings = [&]() {
+ // FIXME: changing options here doesn't work if we're
+ // building through the daemon.
+ verbosity = lvlError;
+ settings.keepLog = false;
+ settings.useSubstitutes = false;
+ settings.maxSilentTime = readInt(in);
+ settings.buildTimeout = readInt(in);
+ if (GET_PROTOCOL_MINOR(clientVersion) >= 2)
+ settings.maxLogSize = readNum<unsigned long>(in);
+ if (GET_PROTOCOL_MINOR(clientVersion) >= 3) {
+ auto nrRepeats = readInt(in);
+ if (nrRepeats != 0) {
+ throw Error("client requested repeating builds, but this is not currently implemented");
+ }
+ // Ignore 'enforceDeterminism'. It used to be true by
+ // default, but also only never had any effect when
+ // `nrRepeats == 0`. We have already asserted that
+ // `nrRepeats` in fact is 0, so we can safely ignore this
+ // without doing something other than what the client
+ // asked for.
+ readInt(in);
+
+ settings.runDiffHook = true;
+ }
+ if (GET_PROTOCOL_MINOR(clientVersion) >= 7) {
+ settings.keepFailed = (bool) readInt(in);
+ }
+ };
+
+ while (true) {
+ ServeProto::Command cmd;
+ try {
+ cmd = (ServeProto::Command) readInt(in);
+ } catch (EndOfFile & e) {
+ break;
+ }
+
+ switch (cmd) {
+
+ case ServeProto::Command::QueryValidPaths: {
+ bool lock = readInt(in);
+ bool substitute = readInt(in);
+ auto paths = ServeProto::Serialise<StorePathSet>::read(*store, rconn);
+ if (lock && writeAllowed)
+ for (auto & path : paths)
+ store->addTempRoot(path);
+
+ if (substitute && writeAllowed) {
+ store->substitutePaths(paths);
+ }
+
+ auto valid = store->queryValidPaths(paths);
+ out << ServeProto::write(*store, wconn, valid);
+ break;
+ }
+
+ case ServeProto::Command::QueryPathInfos: {
+ auto paths = ServeProto::Serialise<StorePathSet>::read(*store, rconn);
+ // !!! Maybe we want a queryPathInfos?
+ for (auto & i : paths) {
+ try {
+ auto info = store->queryPathInfo(i);
+ out << store->printStorePath(info->path);
+ out << ServeProto::write(*store, wconn, static_cast<const UnkeyedValidPathInfo &>(*info));
+ } catch (InvalidPath &) {
+ }
+ }
+ out << "";
+ break;
+ }
+
+ case ServeProto::Command::DumpStorePath:
+ out << store->narFromPath(store->parseStorePath(readString(in)));
+ break;
+
+ case ServeProto::Command::ImportPaths: {
+ if (!writeAllowed) throw Error("importing paths is not allowed");
+ store->importPaths(in, NoCheckSigs); // FIXME: should we skip sig checking?
+ out << 1; // indicate success
+ break;
+ }
+
+ case ServeProto::Command::ExportPaths: {
+ readInt(in); // obsolete
+ store->exportPaths(ServeProto::Serialise<StorePathSet>::read(*store, rconn), out);
+ break;
+ }
+
+ case ServeProto::Command::BuildPaths: {
+
+ if (!writeAllowed) throw Error("building paths is not allowed");
+
+ std::vector<StorePathWithOutputs> paths;
+ for (auto & s : readStrings<Strings>(in))
+ paths.push_back(parsePathWithOutputs(*store, s));
+
+ getBuildSettings();
+
+ try {
+ MonitorFdHup monitor(in.fd);
+ store->buildPaths(toDerivedPaths(paths));
+ out << 0;
+ } catch (Error & e) {
+ assert(e.info().status);
+ out << e.info().status << e.msg();
+ }
+ break;
+ }
+
+ case ServeProto::Command::BuildDerivation: { /* Used by hydra-queue-runner. */
+
+ if (!writeAllowed) throw Error("building paths is not allowed");
+
+ auto drvPath = store->parseStorePath(readString(in));
+ BasicDerivation drv;
+ readDerivation(in, *store, drv, Derivation::nameFromPath(drvPath));
+
+ getBuildSettings();
+
+ MonitorFdHup monitor(in.fd);
+ auto status = store->buildDerivation(drvPath, drv);
+
+ out << ServeProto::write(*store, wconn, status);
+ break;
+ }
+
+ case ServeProto::Command::QueryClosure: {
+ bool includeOutputs = readInt(in);
+ StorePathSet closure;
+ store->computeFSClosure(ServeProto::Serialise<StorePathSet>::read(*store, rconn),
+ closure, false, includeOutputs);
+ out << ServeProto::write(*store, wconn, closure);
+ break;
+ }
+
+ case ServeProto::Command::AddToStoreNar: {
+ if (!writeAllowed) throw Error("importing paths is not allowed");
+
+ auto path = readString(in);
+ auto deriver = readString(in);
+ ValidPathInfo info {
+ store->parseStorePath(path),
+ Hash::parseAny(readString(in), HashType::SHA256),
+ };
+ if (deriver != "")
+ info.deriver = store->parseStorePath(deriver);
+ info.references = ServeProto::Serialise<StorePathSet>::read(*store, rconn);
+ in >> info.registrationTime >> info.narSize >> info.ultimate;
+ info.sigs = readStrings<StringSet>(in);
+ info.ca = ContentAddress::parseOpt(readString(in));
+
+ if (info.narSize == 0)
+ throw Error("narInfo is too old and missing the narSize field");
+
+ SizedSource sizedSource(in, info.narSize);
+
+ store->addToStore(info, sizedSource, NoRepair, NoCheckSigs);
+
+ // consume all the data that has been sent before continuing.
+ sizedSource.drainAll();
+
+ out << 1; // indicate success
+
+ break;
+ }
+
+ default:
+ throw Error("unknown serve command %1%", cmd);
+ }
+
+ out.flush();
+ }
+}
+
+
+static void opGenerateBinaryCacheKey(Strings opFlags, Strings opArgs)
+{
+ for (auto & i : opFlags)
+ throw UsageError("unknown flag '%1%'", i);
+
+ if (opArgs.size() != 3) throw UsageError("three arguments expected");
+ auto i = opArgs.begin();
+ std::string keyName = *i++;
+ std::string secretKeyFile = *i++;
+ std::string publicKeyFile = *i++;
+
+ auto secretKey = SecretKey::generate(keyName);
+
+ writeFile(publicKeyFile, secretKey.toPublicKey().to_string());
+ umask(0077);
+ writeFile(secretKeyFile, secretKey.to_string());
+}
+
+
+static void opVersion(Strings opFlags, Strings opArgs)
+{
+ printVersion("nix-store");
+}
+
+
+/* Scan the arguments; find the operation, set global flags, put all
+ other flags in a list, and put all other arguments in another
+ list. */
+static int main_nix_store(int argc, char * * argv)
+{
+ {
+ Strings opFlags, opArgs;
+ Operation op = 0;
+ bool readFromStdIn = false;
+ std::string opName;
+ bool showHelp = false;
+
+ parseCmdLine(argc, argv, [&](Strings::iterator & arg, const Strings::iterator & end) {
+ Operation oldOp = op;
+
+ if (*arg == "--help")
+ showHelp = true;
+ else if (*arg == "--version")
+ op = opVersion;
+ else if (*arg == "--realise" || *arg == "--realize" || *arg == "-r") {
+ op = opRealise;
+ opName = "-realise";
+ }
+ else if (*arg == "--add" || *arg == "-A"){
+ op = opAdd;
+ opName = "-add";
+ }
+ else if (*arg == "--add-fixed") {
+ op = opAddFixed;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--print-fixed-path")
+ op = opPrintFixedPath;
+ else if (*arg == "--delete") {
+ op = opDelete;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--query" || *arg == "-q") {
+ op = opQuery;
+ opName = "-query";
+ }
+ else if (*arg == "--print-env") {
+ op = opPrintEnv;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--read-log" || *arg == "-l") {
+ op = opReadLog;
+ opName = "-read-log";
+ }
+ else if (*arg == "--dump-db") {
+ op = opDumpDB;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--load-db") {
+ op = opLoadDB;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--register-validity")
+ op = opRegisterValidity;
+ else if (*arg == "--check-validity")
+ op = opCheckValidity;
+ else if (*arg == "--gc") {
+ op = opGC;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--dump") {
+ op = opDump;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--restore") {
+ op = opRestore;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--export") {
+ op = opExport;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--import") {
+ op = opImport;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--init")
+ op = opInit;
+ else if (*arg == "--verify") {
+ op = opVerify;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--verify-path") {
+ op = opVerifyPath;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--repair-path") {
+ op = opRepairPath;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--optimise" || *arg == "--optimize") {
+ op = opOptimise;
+ opName = "-optimise";
+ }
+ else if (*arg == "--serve") {
+ op = opServe;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--generate-binary-cache-key") {
+ op = opGenerateBinaryCacheKey;
+ opName = arg->substr(1);
+ }
+ else if (*arg == "--add-root")
+ gcRoot = absPath(getArg(*arg, arg, end));
+ else if (*arg == "--stdin" && !isatty(STDIN_FILENO))
+ readFromStdIn = true;
+ else if (*arg == "--indirect")
+ ;
+ else if (*arg == "--no-output")
+ noOutput = true;
+ else if (*arg != "" && arg->at(0) == '-') {
+ opFlags.push_back(*arg);
+ if (*arg == "--max-freed" || *arg == "--max-links" || *arg == "--max-atime") /* !!! hack */
+ opFlags.push_back(getArg(*arg, arg, end));
+ }
+ else
+ opArgs.push_back(*arg);
+
+ if (readFromStdIn && op != opImport && op != opRestore && op != opServe) {
+ std::string word;
+ while (std::cin >> word) {
+ opArgs.emplace_back(std::move(word));
+ };
+ }
+
+ if (oldOp && oldOp != op)
+ throw UsageError("only one operation may be specified");
+
+ return true;
+ });
+
+ if (showHelp) showManPage("nix-store" + opName);
+ if (!op) throw UsageError("no operation specified");
+
+ if (op != opDump && op != opRestore) /* !!! hack */
+ store = openStore();
+
+ op(std::move(opFlags), std::move(opArgs));
+
+ return 0;
+ }
+}
+
+void registerNixStore() {
+ LegacyCommands::add("nix-store", main_nix_store);
+}
+
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 21:08:20 +0000