2003-06-17 21:12:58 +00:00
|
|
|
|
#include "globals.hh"
|
2006-03-06 11:21:15 +00:00
|
|
|
|
#include "misc.hh"
|
2003-06-20 10:40:25 +00:00
|
|
|
|
#include "archive.hh"
|
2003-07-04 15:42:03 +00:00
|
|
|
|
#include "shared.hh"
|
2003-09-03 11:20:18 +00:00
|
|
|
|
#include "dotgraph.hh"
|
2010-05-31 16:36:24 +00:00
|
|
|
|
#include "xmlgraph.hh"
|
2006-11-30 17:43:04 +00:00
|
|
|
|
#include "local-store.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
#include "util.hh"
|
2014-02-10 12:43:13 +00:00
|
|
|
|
#include "serve-protocol.hh"
|
2014-02-14 11:31:10 +00:00
|
|
|
|
#include "worker-protocol.hh"
|
2014-07-23 17:26:34 +00:00
|
|
|
|
#include "monitor-fd.hh"
|
2003-03-24 11:50:20 +00:00
|
|
|
|
|
2010-10-04 17:55:38 +00:00
|
|
|
|
#include <iostream>
|
|
|
|
|
#include <algorithm>
|
2012-05-30 04:00:02 +00:00
|
|
|
|
#include <cstdio>
|
|
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
|
|
|
|
#include <bzlib.h>
|
2010-10-04 17:55:38 +00:00
|
|
|
|
|
2015-02-10 10:54:06 +00:00
|
|
|
|
#if HAVE_SODIUM
|
2015-02-04 15:43:32 +00:00
|
|
|
|
#include <sodium.h>
|
2015-02-10 10:54:06 +00:00
|
|
|
|
#endif
|
2015-02-04 15:43:32 +00:00
|
|
|
|
|
2003-03-24 11:50:20 +00:00
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
using namespace nix;
|
|
|
|
|
using std::cin;
|
|
|
|
|
using std::cout;
|
|
|
|
|
|
|
|
|
|
|
2003-06-17 21:12:58 +00:00
|
|
|
|
typedef void (* Operation) (Strings opFlags, Strings opArgs);
|
2003-04-02 15:34:05 +00:00
|
|
|
|
|
|
|
|
|
|
2005-02-01 12:36:25 +00:00
|
|
|
|
static Path gcRoot;
|
|
|
|
|
static int rootNr = 0;
|
2005-02-01 13:48:46 +00:00
|
|
|
|
static bool indirectRoot = false;
|
2013-12-20 13:09:12 +00:00
|
|
|
|
static bool noOutput = false;
|
2005-02-01 12:36:25 +00:00
|
|
|
|
|
|
|
|
|
|
2008-06-09 13:52:45 +00:00
|
|
|
|
LocalStore & ensureLocalStore()
|
|
|
|
|
{
|
|
|
|
|
LocalStore * store2(dynamic_cast<LocalStore *>(store.get()));
|
2010-04-26 12:43:42 +00:00
|
|
|
|
if (!store2) throw Error("you don't have sufficient rights to use this command");
|
2008-06-09 13:52:45 +00:00
|
|
|
|
return *store2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-28 16:33:54 +00:00
|
|
|
|
static Path useDeriver(Path path)
|
2012-07-30 23:55:41 +00:00
|
|
|
|
{
|
2006-10-28 16:33:54 +00:00
|
|
|
|
if (!isDerivation(path)) {
|
2007-06-12 16:53:44 +00:00
|
|
|
|
path = store->queryDeriver(path);
|
2006-10-28 16:33:54 +00:00
|
|
|
|
if (path == "")
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw Error(format("deriver of path ‘%1%’ is not known") % path);
|
2006-10-28 16:33:54 +00:00
|
|
|
|
}
|
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-12-30 17:25:19 +00:00
|
|
|
|
/* Realise the given path. For a derivation that means build it; for
|
|
|
|
|
other paths it means ensure their validity. */
|
2014-02-26 15:32:46 +00:00
|
|
|
|
static PathSet realisePath(Path path, bool build = true)
|
2005-01-25 10:55:33 +00:00
|
|
|
|
{
|
2012-11-26 14:39:10 +00:00
|
|
|
|
DrvPathWithOutputs p = parseDrvPathWithOutputs(path);
|
|
|
|
|
|
|
|
|
|
if (isDerivation(p.first)) {
|
2012-10-02 20:00:09 +00:00
|
|
|
|
if (build) store->buildPaths(singleton<PathSet>(path));
|
2012-11-26 14:39:10 +00:00
|
|
|
|
Derivation drv = derivationFromPath(*store, p.first);
|
2012-08-24 20:58:11 +00:00
|
|
|
|
rootNr++;
|
2011-12-30 17:25:19 +00:00
|
|
|
|
|
2012-11-26 14:39:10 +00:00
|
|
|
|
if (p.second.empty())
|
|
|
|
|
foreach (DerivationOutputs::iterator, i, drv.outputs) p.second.insert(i->first);
|
|
|
|
|
|
2011-12-30 17:25:19 +00:00
|
|
|
|
PathSet outputs;
|
2012-11-26 14:39:10 +00:00
|
|
|
|
foreach (StringSet::iterator, j, p.second) {
|
|
|
|
|
DerivationOutputs::iterator i = drv.outputs.find(*j);
|
|
|
|
|
if (i == drv.outputs.end())
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw Error(format("derivation ‘%1%’ does not have an output named ‘%2%’") % p.first % *j);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
Path outPath = i->second.path;
|
|
|
|
|
if (gcRoot == "")
|
|
|
|
|
printGCWarning();
|
2012-08-24 20:58:11 +00:00
|
|
|
|
else {
|
|
|
|
|
Path rootName = gcRoot;
|
|
|
|
|
if (rootNr > 1) rootName += "-" + int2String(rootNr);
|
|
|
|
|
if (i->first != "out") rootName += "-" + i->first;
|
|
|
|
|
outPath = addPermRoot(*store, outPath, rootName, indirectRoot);
|
|
|
|
|
}
|
2011-12-30 17:25:19 +00:00
|
|
|
|
outputs.insert(outPath);
|
|
|
|
|
}
|
|
|
|
|
return outputs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else {
|
2012-10-02 20:00:09 +00:00
|
|
|
|
if (build) store->ensurePath(path);
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else if (!store->isValidPath(path)) throw Error(format("path ‘%1%’ does not exist and cannot be created") % path);
|
2014-02-26 15:32:46 +00:00
|
|
|
|
if (gcRoot == "")
|
|
|
|
|
printGCWarning();
|
|
|
|
|
else {
|
|
|
|
|
Path rootName = gcRoot;
|
|
|
|
|
rootNr++;
|
|
|
|
|
if (rootNr > 1) rootName += "-" + int2String(rootNr);
|
|
|
|
|
path = addPermRoot(*store, path, rootName, indirectRoot);
|
|
|
|
|
}
|
2011-12-30 17:25:19 +00:00
|
|
|
|
return singleton<PathSet>(path);
|
2005-01-25 10:55:33 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Realise the given paths. */
|
|
|
|
|
static void opRealise(Strings opFlags, Strings opArgs)
|
2003-03-14 16:43:14 +00:00
|
|
|
|
{
|
2008-08-04 13:44:46 +00:00
|
|
|
|
bool dryRun = false;
|
2014-02-18 00:01:14 +00:00
|
|
|
|
BuildMode buildMode = bmNormal;
|
2012-11-19 23:27:25 +00:00
|
|
|
|
bool ignoreUnknown = false;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-08-04 13:44:46 +00:00
|
|
|
|
foreach (Strings::iterator, i, opFlags)
|
|
|
|
|
if (*i == "--dry-run") dryRun = true;
|
2014-02-18 00:01:14 +00:00
|
|
|
|
else if (*i == "--repair") buildMode = bmRepair;
|
|
|
|
|
else if (*i == "--check") buildMode = bmCheck;
|
2012-11-19 23:27:25 +00:00
|
|
|
|
else if (*i == "--ignore-unknown") ignoreUnknown = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2003-03-13 16:28:32 +00:00
|
|
|
|
|
2012-11-19 23:27:25 +00:00
|
|
|
|
Paths paths;
|
2012-11-26 14:39:10 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
|
|
|
|
DrvPathWithOutputs p = parseDrvPathWithOutputs(*i);
|
|
|
|
|
paths.push_back(makeDrvPathWithOutputs(followLinksToStorePath(p.first), p.second));
|
|
|
|
|
}
|
2012-11-19 23:27:25 +00:00
|
|
|
|
|
|
|
|
|
unsigned long long downloadSize, narSize;
|
|
|
|
|
PathSet willBuild, willSubstitute, unknown;
|
|
|
|
|
queryMissing(*store, PathSet(paths.begin(), paths.end()),
|
|
|
|
|
willBuild, willSubstitute, unknown, downloadSize, narSize);
|
|
|
|
|
|
|
|
|
|
if (ignoreUnknown) {
|
|
|
|
|
Paths paths2;
|
|
|
|
|
foreach (Paths::iterator, i, paths)
|
|
|
|
|
if (unknown.find(*i) == unknown.end()) paths2.push_back(*i);
|
|
|
|
|
paths = paths2;
|
|
|
|
|
unknown = PathSet();
|
|
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2012-11-19 23:27:25 +00:00
|
|
|
|
printMissing(willBuild, willSubstitute, unknown, downloadSize, narSize);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-08-04 13:44:46 +00:00
|
|
|
|
if (dryRun) return;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2012-06-27 20:58:15 +00:00
|
|
|
|
/* Build all paths at the same time to exploit parallelism. */
|
2014-02-18 00:01:14 +00:00
|
|
|
|
store->buildPaths(PathSet(paths.begin(), paths.end()), buildMode);
|
2005-01-19 15:02:02 +00:00
|
|
|
|
|
2012-11-19 23:27:25 +00:00
|
|
|
|
if (!ignoreUnknown)
|
|
|
|
|
foreach (Paths::iterator, i, paths) {
|
|
|
|
|
PathSet paths = realisePath(*i, false);
|
2013-12-20 12:10:14 +00:00
|
|
|
|
if (!noOutput)
|
|
|
|
|
foreach (PathSet::iterator, j, paths)
|
|
|
|
|
cout << format("%1%\n") % *j;
|
2012-11-19 23:27:25 +00:00
|
|
|
|
}
|
2003-04-02 15:34:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-07 14:01:51 +00:00
|
|
|
|
/* Add files to the Nix store and print the resulting paths. */
|
2003-06-17 21:12:58 +00:00
|
|
|
|
static void opAdd(Strings opFlags, Strings opArgs)
|
2003-04-02 15:34:05 +00:00
|
|
|
|
{
|
2003-06-17 21:12:58 +00:00
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
2003-04-02 15:34:05 +00:00
|
|
|
|
|
2005-03-26 22:06:57 +00:00
|
|
|
|
for (Strings::iterator i = opArgs.begin(); i != opArgs.end(); ++i)
|
2006-11-30 17:43:04 +00:00
|
|
|
|
cout << format("%1%\n") % store->addToStore(*i);
|
2003-03-13 16:28:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-07 14:01:51 +00:00
|
|
|
|
/* Preload the output of a fixed-output derivation into the Nix
|
|
|
|
|
store. */
|
|
|
|
|
static void opAddFixed(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
bool recursive = false;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-04-07 14:01:51 +00:00
|
|
|
|
for (Strings::iterator i = opFlags.begin();
|
|
|
|
|
i != opFlags.end(); ++i)
|
|
|
|
|
if (*i == "--recursive") recursive = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2005-04-07 14:01:51 +00:00
|
|
|
|
|
|
|
|
|
if (opArgs.empty())
|
|
|
|
|
throw UsageError("first argument must be hash algorithm");
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-12-03 16:10:17 +00:00
|
|
|
|
HashType hashAlgo = parseHashType(opArgs.front());
|
2005-04-07 14:01:51 +00:00
|
|
|
|
opArgs.pop_front();
|
|
|
|
|
|
|
|
|
|
for (Strings::iterator i = opArgs.begin(); i != opArgs.end(); ++i)
|
2008-12-03 15:06:30 +00:00
|
|
|
|
cout << format("%1%\n") % store->addToStore(*i, recursive, hashAlgo);
|
2005-04-07 14:01:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Hack to support caching in `nix-prefetch-url'. */
|
|
|
|
|
static void opPrintFixedPath(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
bool recursive = false;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-04-07 14:01:51 +00:00
|
|
|
|
for (Strings::iterator i = opFlags.begin();
|
|
|
|
|
i != opFlags.end(); ++i)
|
|
|
|
|
if (*i == "--recursive") recursive = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2005-04-07 14:01:51 +00:00
|
|
|
|
|
2008-12-03 15:06:30 +00:00
|
|
|
|
if (opArgs.size() != 3)
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw UsageError(format("‘--print-fixed-path’ requires three arguments"));
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-04-07 14:01:51 +00:00
|
|
|
|
Strings::iterator i = opArgs.begin();
|
2008-12-03 16:10:17 +00:00
|
|
|
|
HashType hashAlgo = parseHashType(*i++);
|
2005-04-07 14:01:51 +00:00
|
|
|
|
string hash = *i++;
|
|
|
|
|
string name = *i++;
|
|
|
|
|
|
|
|
|
|
cout << format("%1%\n") %
|
2006-11-13 16:48:27 +00:00
|
|
|
|
makeFixedOutputPath(recursive, hashAlgo,
|
2008-12-03 16:10:17 +00:00
|
|
|
|
parseHash16or32(hashAlgo, hash), name);
|
2005-04-07 14:01:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-12-30 17:25:19 +00:00
|
|
|
|
static PathSet maybeUseOutputs(const Path & storePath, bool useOutput, bool forceRealise)
|
2003-07-29 10:43:12 +00:00
|
|
|
|
{
|
2005-01-25 10:55:33 +00:00
|
|
|
|
if (forceRealise) realisePath(storePath);
|
2005-01-19 14:36:00 +00:00
|
|
|
|
if (useOutput && isDerivation(storePath)) {
|
2011-08-31 21:11:50 +00:00
|
|
|
|
Derivation drv = derivationFromPath(*store, storePath);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
PathSet outputs;
|
|
|
|
|
foreach (DerivationOutputs::iterator, i, drv.outputs)
|
|
|
|
|
outputs.insert(i->second.path);
|
|
|
|
|
return outputs;
|
2005-01-19 14:36:00 +00:00
|
|
|
|
}
|
2011-12-30 17:25:19 +00:00
|
|
|
|
else return singleton<PathSet>(storePath);
|
2003-07-29 10:43:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-02-17 15:57:46 +00:00
|
|
|
|
/* Some code to print a tree representation of a derivation dependency
|
|
|
|
|
graph. Topological sorting is used to keep the tree relatively
|
|
|
|
|
flat. */
|
|
|
|
|
|
|
|
|
|
const string treeConn = "+---";
|
|
|
|
|
const string treeLine = "| ";
|
|
|
|
|
const string treeNull = " ";
|
|
|
|
|
|
|
|
|
|
|
2005-04-08 12:57:16 +00:00
|
|
|
|
static void printTree(const Path & path,
|
2005-02-17 15:57:46 +00:00
|
|
|
|
const string & firstPad, const string & tailPad, PathSet & done)
|
|
|
|
|
{
|
2005-04-08 12:57:16 +00:00
|
|
|
|
if (done.find(path) != done.end()) {
|
|
|
|
|
cout << format("%1%%2% [...]\n") % firstPad % path;
|
2005-02-17 15:57:46 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
2005-04-08 12:57:16 +00:00
|
|
|
|
done.insert(path);
|
2005-02-17 15:57:46 +00:00
|
|
|
|
|
2005-04-08 12:57:16 +00:00
|
|
|
|
cout << format("%1%%2%\n") % firstPad % path;
|
|
|
|
|
|
|
|
|
|
PathSet references;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
store->queryReferences(path, references);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-02-22 15:23:24 +00:00
|
|
|
|
/* Topologically sort under the relation A < B iff A \in
|
2005-02-17 15:57:46 +00:00
|
|
|
|
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. */
|
2011-08-31 21:11:50 +00:00
|
|
|
|
Paths sorted = topoSortPaths(*store, references);
|
2005-02-17 15:57:46 +00:00
|
|
|
|
reverse(sorted.begin(), sorted.end());
|
|
|
|
|
|
2013-03-08 00:24:59 +00:00
|
|
|
|
foreach (Paths::iterator, i, sorted) {
|
2005-02-17 15:57:46 +00:00
|
|
|
|
Paths::iterator j = i; ++j;
|
2005-04-08 12:57:16 +00:00
|
|
|
|
printTree(*i, tailPad + treeConn,
|
2005-02-17 15:57:46 +00:00
|
|
|
|
j == sorted.end() ? tailPad + treeNull : tailPad + treeLine,
|
|
|
|
|
done);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-07-08 13:22:08 +00:00
|
|
|
|
/* Perform various sorts of queries. */
|
|
|
|
|
static void opQuery(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2014-10-14 10:15:39 +00:00
|
|
|
|
enum QueryType
|
|
|
|
|
{ qDefault, qOutputs, qRequisites, qReferences, qReferrers
|
|
|
|
|
, qReferrersClosure, qDeriver, qBinding, qHash, qSize
|
|
|
|
|
, qTree, qGraph, qXml, qResolve, qRoots };
|
|
|
|
|
QueryType query = qDefault;
|
2005-01-19 14:36:00 +00:00
|
|
|
|
bool useOutput = false;
|
|
|
|
|
bool includeOutputs = false;
|
2005-01-25 10:55:33 +00:00
|
|
|
|
bool forceRealise = false;
|
2005-02-07 14:32:44 +00:00
|
|
|
|
string bindingName;
|
2003-07-21 14:46:01 +00:00
|
|
|
|
|
2014-10-14 10:15:39 +00:00
|
|
|
|
foreach (Strings::iterator, i, opFlags) {
|
|
|
|
|
QueryType prev = query;
|
2005-01-19 14:36:00 +00:00
|
|
|
|
if (*i == "--outputs") query = qOutputs;
|
2003-11-18 11:22:29 +00:00
|
|
|
|
else if (*i == "--requisites" || *i == "-R") query = qRequisites;
|
2005-01-19 16:59:56 +00:00
|
|
|
|
else if (*i == "--references") query = qReferences;
|
2005-12-13 21:04:48 +00:00
|
|
|
|
else if (*i == "--referrers" || *i == "--referers") query = qReferrers;
|
|
|
|
|
else if (*i == "--referrers-closure" || *i == "--referers-closure") query = qReferrersClosure;
|
2005-02-07 13:40:40 +00:00
|
|
|
|
else if (*i == "--deriver" || *i == "-d") query = qDeriver;
|
2005-02-07 14:32:44 +00:00
|
|
|
|
else if (*i == "--binding" || *i == "-b") {
|
|
|
|
|
if (opArgs.size() == 0)
|
|
|
|
|
throw UsageError("expected binding name");
|
|
|
|
|
bindingName = opArgs.front();
|
|
|
|
|
opArgs.pop_front();
|
|
|
|
|
query = qBinding;
|
|
|
|
|
}
|
2005-03-02 15:57:06 +00:00
|
|
|
|
else if (*i == "--hash") query = qHash;
|
2010-11-17 12:40:52 +00:00
|
|
|
|
else if (*i == "--size") query = qSize;
|
2005-02-17 15:57:46 +00:00
|
|
|
|
else if (*i == "--tree") query = qTree;
|
2003-07-28 12:19:23 +00:00
|
|
|
|
else if (*i == "--graph") query = qGraph;
|
2010-05-31 16:36:24 +00:00
|
|
|
|
else if (*i == "--xml") query = qXml;
|
2007-01-13 19:50:42 +00:00
|
|
|
|
else if (*i == "--resolve") query = qResolve;
|
2009-11-23 18:16:25 +00:00
|
|
|
|
else if (*i == "--roots") query = qRoots;
|
2005-01-19 14:36:00 +00:00
|
|
|
|
else if (*i == "--use-output" || *i == "-u") useOutput = true;
|
2013-03-08 00:24:59 +00:00
|
|
|
|
else if (*i == "--force-realise" || *i == "--force-realize" || *i == "-f") forceRealise = true;
|
2005-01-19 14:36:00 +00:00
|
|
|
|
else if (*i == "--include-outputs") includeOutputs = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2014-10-14 10:15:39 +00:00
|
|
|
|
if (prev != qDefault && prev != query)
|
|
|
|
|
throw UsageError(format("query type ‘%1%’ conflicts with earlier flag") % *i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query == qDefault) query = qOutputs;
|
2003-07-21 14:46:01 +00:00
|
|
|
|
|
2014-08-20 19:26:37 +00:00
|
|
|
|
RunPager pager;
|
|
|
|
|
|
2003-07-21 14:46:01 +00:00
|
|
|
|
switch (query) {
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-01-19 14:36:00 +00:00
|
|
|
|
case qOutputs: {
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
2007-11-29 16:18:24 +00:00
|
|
|
|
*i = followLinksToStorePath(*i);
|
2005-01-25 10:55:33 +00:00
|
|
|
|
if (forceRealise) realisePath(*i);
|
2011-08-31 21:11:50 +00:00
|
|
|
|
Derivation drv = derivationFromPath(*store, *i);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
foreach (DerivationOutputs::iterator, j, drv.outputs)
|
|
|
|
|
cout << format("%1%\n") % j->second.path;
|
2003-07-21 14:46:01 +00:00
|
|
|
|
}
|
2003-07-08 13:22:08 +00:00
|
|
|
|
break;
|
2003-07-10 13:41:28 +00:00
|
|
|
|
}
|
2003-07-08 13:22:08 +00:00
|
|
|
|
|
2005-01-19 16:59:56 +00:00
|
|
|
|
case qRequisites:
|
|
|
|
|
case qReferences:
|
2005-12-13 21:04:48 +00:00
|
|
|
|
case qReferrers:
|
|
|
|
|
case qReferrersClosure: {
|
2005-01-19 14:36:00 +00:00
|
|
|
|
PathSet paths;
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
2011-12-30 17:25:19 +00:00
|
|
|
|
PathSet ps = maybeUseOutputs(followLinksToStorePath(*i), useOutput, forceRealise);
|
|
|
|
|
foreach (PathSet::iterator, j, ps) {
|
|
|
|
|
if (query == qRequisites) computeFSClosure(*store, *j, paths, false, includeOutputs);
|
|
|
|
|
else if (query == qReferences) store->queryReferences(*j, paths);
|
|
|
|
|
else if (query == qReferrers) store->queryReferrers(*j, paths);
|
|
|
|
|
else if (query == qReferrersClosure) computeFSClosure(*store, *j, paths, true);
|
|
|
|
|
}
|
2003-07-21 14:46:01 +00:00
|
|
|
|
}
|
2011-08-31 21:11:50 +00:00
|
|
|
|
Paths sorted = topoSortPaths(*store, paths);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
for (Paths::reverse_iterator i = sorted.rbegin();
|
2007-02-21 22:45:10 +00:00
|
|
|
|
i != sorted.rend(); ++i)
|
|
|
|
|
cout << format("%s\n") % *i;
|
2003-07-21 14:46:01 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-07 13:40:40 +00:00
|
|
|
|
case qDeriver:
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
2007-11-29 16:18:24 +00:00
|
|
|
|
Path deriver = store->queryDeriver(followLinksToStorePath(*i));
|
2005-02-07 13:40:40 +00:00
|
|
|
|
cout << format("%1%\n") %
|
|
|
|
|
(deriver == "" ? "unknown-deriver" : deriver);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2005-02-07 14:32:44 +00:00
|
|
|
|
|
|
|
|
|
case qBinding:
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
2007-11-29 16:18:24 +00:00
|
|
|
|
Path path = useDeriver(followLinksToStorePath(*i));
|
2011-08-31 21:11:50 +00:00
|
|
|
|
Derivation drv = derivationFromPath(*store, path);
|
2005-02-07 14:32:44 +00:00
|
|
|
|
StringPairs::iterator j = drv.env.find(bindingName);
|
|
|
|
|
if (j == drv.env.end())
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw Error(format("derivation ‘%1%’ has no environment binding named ‘%2%’")
|
2006-10-28 16:33:54 +00:00
|
|
|
|
% path % bindingName);
|
2005-02-07 14:32:44 +00:00
|
|
|
|
cout << format("%1%\n") % j->second;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2005-02-07 13:40:40 +00:00
|
|
|
|
|
2005-03-02 15:57:06 +00:00
|
|
|
|
case qHash:
|
2010-11-17 12:40:52 +00:00
|
|
|
|
case qSize:
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
2011-12-30 17:25:19 +00:00
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(*i), useOutput, forceRealise);
|
|
|
|
|
foreach (PathSet::iterator, j, paths) {
|
|
|
|
|
ValidPathInfo info = store->queryPathInfo(*j);
|
|
|
|
|
if (query == qHash) {
|
|
|
|
|
assert(info.hash.type == htSHA256);
|
|
|
|
|
cout << format("sha256:%1%\n") % printHash32(info.hash);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
} else if (query == qSize)
|
2011-12-30 17:25:19 +00:00
|
|
|
|
cout << format("%1%\n") % info.narSize;
|
|
|
|
|
}
|
2005-03-02 15:57:06 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2005-02-17 15:57:46 +00:00
|
|
|
|
case qTree: {
|
|
|
|
|
PathSet done;
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs)
|
2007-11-29 16:18:24 +00:00
|
|
|
|
printTree(followLinksToStorePath(*i), "", "", done);
|
2005-02-17 15:57:46 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2003-07-28 12:19:23 +00:00
|
|
|
|
case qGraph: {
|
2003-10-08 15:06:59 +00:00
|
|
|
|
PathSet roots;
|
2011-12-30 17:25:19 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(*i), useOutput, forceRealise);
|
|
|
|
|
roots.insert(paths.begin(), paths.end());
|
|
|
|
|
}
|
2010-05-31 16:36:24 +00:00
|
|
|
|
printDotGraph(roots);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case qXml: {
|
|
|
|
|
PathSet roots;
|
2011-12-30 17:25:19 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(*i), useOutput, forceRealise);
|
|
|
|
|
roots.insert(paths.begin(), paths.end());
|
|
|
|
|
}
|
2010-05-31 16:36:24 +00:00
|
|
|
|
printXmlGraph(roots);
|
2003-07-28 12:19:23 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-13 19:50:42 +00:00
|
|
|
|
case qResolve: {
|
2009-11-23 18:16:25 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs)
|
2007-11-29 16:18:24 +00:00
|
|
|
|
cout << format("%1%\n") % followLinksToStorePath(*i);
|
2007-01-13 19:50:42 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2009-11-23 18:16:25 +00:00
|
|
|
|
case qRoots: {
|
|
|
|
|
PathSet referrers;
|
2011-12-30 17:25:19 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(*i), useOutput, forceRealise);
|
|
|
|
|
foreach (PathSet::iterator, j, paths)
|
2012-12-20 17:41:44 +00:00
|
|
|
|
computeFSClosure(*store, *j, referrers, true,
|
|
|
|
|
settings.gcKeepOutputs, settings.gcKeepDerivations);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
}
|
2009-11-23 18:16:25 +00:00
|
|
|
|
Roots roots = store->findRoots();
|
|
|
|
|
foreach (Roots::iterator, i, roots)
|
|
|
|
|
if (referrers.find(i->second) != referrers.end())
|
|
|
|
|
cout << format("%1%\n") % i->first;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2003-07-08 13:22:08 +00:00
|
|
|
|
default:
|
|
|
|
|
abort();
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-07-10 18:48:11 +00:00
|
|
|
|
|
|
|
|
|
|
2012-01-17 23:07:22 +00:00
|
|
|
|
static string shellEscape(const string & s)
|
|
|
|
|
{
|
|
|
|
|
string r;
|
|
|
|
|
foreach (string::const_iterator, i, s)
|
|
|
|
|
if (*i == '\'') r += "'\\''"; else r += *i;
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void opPrintEnv(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
2014-08-20 15:00:17 +00:00
|
|
|
|
if (opArgs.size() != 1) throw UsageError("‘--print-env’ requires one derivation store path");
|
2012-01-17 23:07:22 +00:00
|
|
|
|
|
|
|
|
|
Path drvPath = opArgs.front();
|
|
|
|
|
Derivation drv = derivationFromPath(*store, drvPath);
|
|
|
|
|
|
|
|
|
|
/* Print each environment variable in the derivation in a format
|
|
|
|
|
that can be sourced by the shell. */
|
|
|
|
|
foreach (StringPairs::iterator, i, drv.env)
|
|
|
|
|
cout << format("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='";
|
|
|
|
|
foreach (Strings::iterator, i, drv.args) {
|
|
|
|
|
if (i != drv.args.begin()) cout << ' ';
|
|
|
|
|
cout << shellEscape(*i);
|
|
|
|
|
}
|
|
|
|
|
cout << "'\n";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-28 16:33:54 +00:00
|
|
|
|
static void opReadLog(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
|
|
|
|
|
2014-08-20 13:12:58 +00:00
|
|
|
|
RunPager pager;
|
|
|
|
|
|
2012-05-30 04:00:02 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
2007-11-29 16:18:24 +00:00
|
|
|
|
Path path = useDeriver(followLinksToStorePath(*i));
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2014-05-21 15:19:36 +00:00
|
|
|
|
string baseName = baseNameOf(path);
|
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
|
|
for (int j = 0; j < 2; j++) {
|
2013-03-08 00:24:59 +00:00
|
|
|
|
|
|
|
|
|
Path logPath =
|
|
|
|
|
j == 0
|
|
|
|
|
? (format("%1%/%2%/%3%/%4%") % settings.nixLogDir % drvsLogDir % string(baseName, 0, 2) % string(baseName, 2)).str()
|
|
|
|
|
: (format("%1%/%2%/%3%") % settings.nixLogDir % drvsLogDir % baseName).str();
|
|
|
|
|
Path logBz2Path = logPath + ".bz2";
|
|
|
|
|
|
|
|
|
|
if (pathExists(logPath)) {
|
|
|
|
|
/* !!! Make this run in O(1) memory. */
|
|
|
|
|
string log = readFile(logPath);
|
2014-12-12 13:35:44 +00:00
|
|
|
|
writeFull(STDOUT_FILENO, log);
|
2014-05-21 15:19:36 +00:00
|
|
|
|
found = true;
|
2013-03-08 00:24:59 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2013-03-07 22:55:55 +00:00
|
|
|
|
|
2013-03-08 00:24:59 +00:00
|
|
|
|
else if (pathExists(logBz2Path)) {
|
|
|
|
|
AutoCloseFD fd = open(logBz2Path.c_str(), O_RDONLY);
|
|
|
|
|
FILE * f = 0;
|
|
|
|
|
if (fd == -1 || (f = fdopen(fd.borrow(), "r")) == 0)
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw SysError(format("opening file ‘%1%’") % logBz2Path);
|
2013-03-08 00:24:59 +00:00
|
|
|
|
int err;
|
|
|
|
|
BZFILE * bz = BZ2_bzReadOpen(&err, f, 0, 0, 0, 0);
|
2014-08-20 15:00:17 +00:00
|
|
|
|
if (!bz) throw Error(format("cannot open bzip2 file ‘%1%’") % logBz2Path);
|
2013-03-08 00:24:59 +00:00
|
|
|
|
unsigned char buf[128 * 1024];
|
|
|
|
|
do {
|
|
|
|
|
int n = BZ2_bzRead(&err, bz, buf, sizeof(buf));
|
|
|
|
|
if (err != BZ_OK && err != BZ_STREAM_END)
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw Error(format("error reading bzip2 file ‘%1%’") % logBz2Path);
|
2013-03-08 00:24:59 +00:00
|
|
|
|
writeFull(STDOUT_FILENO, buf, n);
|
|
|
|
|
} while (err != BZ_STREAM_END);
|
|
|
|
|
BZ2_bzReadClose(&err, bz);
|
2014-05-21 15:19:36 +00:00
|
|
|
|
found = true;
|
2013-03-08 00:24:59 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2013-03-07 22:55:55 +00:00
|
|
|
|
}
|
2014-05-21 15:19:36 +00:00
|
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
|
for (auto & i : settings.logServers) {
|
|
|
|
|
string prefix = i;
|
|
|
|
|
if (!prefix.empty() && prefix.back() != '/') prefix += '/';
|
|
|
|
|
string url = prefix + baseName;
|
|
|
|
|
try {
|
|
|
|
|
string log = runProgram(CURL, true, {"--fail", "--location", "--silent", "--", url});
|
|
|
|
|
std::cout << "(using build log from " << url << ")" << std::endl;
|
|
|
|
|
std::cout << log;
|
|
|
|
|
found = true;
|
|
|
|
|
break;
|
|
|
|
|
} catch (ExecError & e) {
|
|
|
|
|
/* Ignore errors from curl. FIXME: actually, might be
|
|
|
|
|
nice to print a warning on HTTP status != 404. */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-20 15:00:17 +00:00
|
|
|
|
if (!found) throw Error(format("build log of derivation ‘%1%’ is not available") % path);
|
2006-10-28 16:33:54 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-01-29 18:17:36 +00:00
|
|
|
|
static void opDumpDB(Strings opFlags, Strings opArgs)
|
2004-02-14 21:44:18 +00:00
|
|
|
|
{
|
2008-01-29 18:17:36 +00:00
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
|
|
|
|
if (!opArgs.empty())
|
|
|
|
|
throw UsageError("no arguments expected");
|
2012-07-11 14:49:04 +00:00
|
|
|
|
PathSet validPaths = store->queryAllValidPaths();
|
2010-11-16 17:11:46 +00:00
|
|
|
|
foreach (PathSet::iterator, i, validPaths)
|
|
|
|
|
cout << store->makeValidityRegistration(singleton<PathSet>(*i), true, true);
|
2008-01-29 18:17:36 +00:00
|
|
|
|
}
|
2006-11-13 16:48:27 +00:00
|
|
|
|
|
2005-03-23 11:25:20 +00:00
|
|
|
|
|
2008-01-29 18:17:36 +00:00
|
|
|
|
static void registerValidity(bool reregister, bool hashGiven, bool canonicalise)
|
|
|
|
|
{
|
2005-03-23 13:07:28 +00:00
|
|
|
|
ValidPathInfos infos;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-03-23 11:25:20 +00:00
|
|
|
|
while (1) {
|
2008-01-29 18:17:36 +00:00
|
|
|
|
ValidPathInfo info = decodeValidPathInfo(cin, hashGiven);
|
2007-08-12 00:29:28 +00:00
|
|
|
|
if (info.path == "") break;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
if (!store->isValidPath(info.path) || reregister) {
|
2005-03-23 12:06:57 +00:00
|
|
|
|
/* !!! races */
|
2008-01-29 18:17:36 +00:00
|
|
|
|
if (canonicalise)
|
2013-03-08 00:24:59 +00:00
|
|
|
|
canonicalisePathMetaData(info.path, -1);
|
2010-11-16 17:11:46 +00:00
|
|
|
|
if (!hashGiven) {
|
|
|
|
|
HashResult hash = hashPath(htSHA256, info.path);
|
|
|
|
|
info.hash = hash.first;
|
|
|
|
|
info.narSize = hash.second;
|
|
|
|
|
}
|
2005-03-23 13:07:28 +00:00
|
|
|
|
infos.push_back(info);
|
2005-03-23 12:06:57 +00:00
|
|
|
|
}
|
2005-03-23 11:25:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-09 13:52:45 +00:00
|
|
|
|
ensureLocalStore().registerValidPaths(infos);
|
2004-02-14 21:44:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-01-29 18:17:36 +00:00
|
|
|
|
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;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-01-29 18:17:36 +00:00
|
|
|
|
for (Strings::iterator i = opFlags.begin();
|
|
|
|
|
i != opFlags.end(); ++i)
|
|
|
|
|
if (*i == "--reregister") reregister = true;
|
|
|
|
|
else if (*i == "--hash-given") hashGiven = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2008-01-29 18:17:36 +00:00
|
|
|
|
|
|
|
|
|
if (!opArgs.empty()) throw UsageError("no arguments expected");
|
|
|
|
|
|
|
|
|
|
registerValidity(reregister, hashGiven, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-03-23 11:25:20 +00:00
|
|
|
|
static void opCheckValidity(Strings opFlags, Strings opArgs)
|
2004-02-14 21:44:18 +00:00
|
|
|
|
{
|
2007-02-21 17:57:59 +00:00
|
|
|
|
bool printInvalid = false;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2007-02-21 17:57:59 +00:00
|
|
|
|
for (Strings::iterator i = opFlags.begin();
|
|
|
|
|
i != opFlags.end(); ++i)
|
|
|
|
|
if (*i == "--print-invalid") printInvalid = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2004-02-14 21:44:18 +00:00
|
|
|
|
|
|
|
|
|
for (Strings::iterator i = opArgs.begin();
|
|
|
|
|
i != opArgs.end(); ++i)
|
2007-02-21 17:57:59 +00:00
|
|
|
|
{
|
2007-11-29 16:18:24 +00:00
|
|
|
|
Path path = followLinksToStorePath(*i);
|
2011-09-06 12:06:30 +00:00
|
|
|
|
if (!store->isValidPath(path)) {
|
2007-02-21 17:57:59 +00:00
|
|
|
|
if (printInvalid)
|
|
|
|
|
cout << format("%1%\n") % path;
|
|
|
|
|
else
|
2014-08-20 15:00:17 +00:00
|
|
|
|
throw Error(format("path ‘%1%’ is not valid") % path);
|
2011-09-06 12:06:30 +00:00
|
|
|
|
}
|
2007-02-21 17:57:59 +00:00
|
|
|
|
}
|
2004-02-14 21:44:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-08-02 02:34:46 +00:00
|
|
|
|
static string showBytes(unsigned long long bytes)
|
2007-10-09 22:14:27 +00:00
|
|
|
|
{
|
2012-08-02 02:34:46 +00:00
|
|
|
|
return (format("%.2f MiB") % (bytes / (1024.0 * 1024.0))).str();
|
2007-10-09 22:14:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-30 23:55:41 +00:00
|
|
|
|
struct PrintFreed
|
2005-12-15 21:11:39 +00:00
|
|
|
|
{
|
2008-09-17 10:02:55 +00:00
|
|
|
|
bool show;
|
2008-06-18 09:34:17 +00:00
|
|
|
|
const GCResults & results;
|
2008-09-17 10:02:55 +00:00
|
|
|
|
PrintFreed(bool show, const GCResults & results)
|
|
|
|
|
: show(show), results(results) { }
|
2012-07-30 23:55:41 +00:00
|
|
|
|
~PrintFreed()
|
2005-12-15 21:11:39 +00:00
|
|
|
|
{
|
|
|
|
|
if (show)
|
2008-09-17 12:53:33 +00:00
|
|
|
|
cout << format("%1% store paths deleted, %2% freed\n")
|
|
|
|
|
% results.paths.size()
|
2012-08-02 02:34:46 +00:00
|
|
|
|
% showBytes(results.bytesFreed);
|
2005-12-15 21:11:39 +00:00
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2004-08-25 11:43:49 +00:00
|
|
|
|
static void opGC(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2009-11-23 17:23:12 +00:00
|
|
|
|
bool printRoots = false;
|
2008-06-18 09:34:17 +00:00
|
|
|
|
GCOptions options;
|
|
|
|
|
options.action = GCOptions::gcDeleteDead;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-06-18 09:34:17 +00:00
|
|
|
|
GCResults results;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2004-08-25 11:43:49 +00:00
|
|
|
|
/* Do what? */
|
2008-09-17 10:02:55 +00:00
|
|
|
|
foreach (Strings::iterator, i, opFlags)
|
2009-11-23 17:23:12 +00:00
|
|
|
|
if (*i == "--print-roots") printRoots = true;
|
2008-06-18 09:34:17 +00:00
|
|
|
|
else if (*i == "--print-live") options.action = GCOptions::gcReturnLive;
|
|
|
|
|
else if (*i == "--print-dead") options.action = GCOptions::gcReturnDead;
|
|
|
|
|
else if (*i == "--delete") options.action = GCOptions::gcDeleteDead;
|
2009-03-26 11:02:07 +00:00
|
|
|
|
else if (*i == "--max-freed") {
|
2014-02-17 13:48:50 +00:00
|
|
|
|
long long maxFreed = getIntArg<long long>(*i, i, opFlags.end(), true);
|
2012-08-01 23:14:30 +00:00
|
|
|
|
options.maxFreed = maxFreed >= 0 ? maxFreed : 0;
|
2009-03-26 11:02:07 +00:00
|
|
|
|
}
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("bad sub-operation ‘%1%’ in GC") % *i);
|
2005-01-27 15:21:29 +00:00
|
|
|
|
|
2008-09-17 14:52:35 +00:00
|
|
|
|
if (!opArgs.empty()) throw UsageError("no arguments expected");
|
2004-08-25 11:43:49 +00:00
|
|
|
|
|
2009-11-23 17:23:12 +00:00
|
|
|
|
if (printRoots) {
|
|
|
|
|
Roots roots = store->findRoots();
|
|
|
|
|
foreach (Roots::iterator, i, roots)
|
|
|
|
|
cout << i->first << " -> " << i->second << std::endl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else {
|
|
|
|
|
PrintFreed freed(options.action == GCOptions::gcDeleteDead, results);
|
|
|
|
|
store->collectGarbage(options, results);
|
|
|
|
|
|
|
|
|
|
if (options.action != GCOptions::gcDeleteDead)
|
|
|
|
|
foreach (PathSet::iterator, i, results.paths)
|
|
|
|
|
cout << *i << std::endl;
|
|
|
|
|
}
|
2004-08-25 11:43:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-12-23 21:08:42 +00:00
|
|
|
|
/* 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)
|
|
|
|
|
{
|
2008-06-18 09:34:17 +00:00
|
|
|
|
GCOptions options;
|
|
|
|
|
options.action = GCOptions::gcDeleteSpecific;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-09-17 10:02:55 +00:00
|
|
|
|
foreach (Strings::iterator, i, opFlags)
|
2008-06-18 09:34:17 +00:00
|
|
|
|
if (*i == "--ignore-liveness") options.ignoreLiveness = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2005-12-23 21:08:42 +00:00
|
|
|
|
|
2008-09-17 10:02:55 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs)
|
2008-06-18 09:34:17 +00:00
|
|
|
|
options.pathsToDelete.insert(followLinksToStorePath(*i));
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2008-06-18 09:34:17 +00:00
|
|
|
|
GCResults results;
|
2008-09-17 10:02:55 +00:00
|
|
|
|
PrintFreed freed(true, results);
|
2008-06-18 09:34:17 +00:00
|
|
|
|
store->collectGarbage(options, results);
|
2005-12-23 21:08:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-07-08 10:00:46 +00:00
|
|
|
|
/* Dump a path as a Nix archive. The archive is written to standard
|
2003-06-23 14:08:34 +00:00
|
|
|
|
output. */
|
2003-06-18 14:34:43 +00:00
|
|
|
|
static void opDump(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
|
|
|
|
if (opArgs.size() != 1) throw UsageError("only one argument allowed");
|
|
|
|
|
|
2006-11-30 19:19:59 +00:00
|
|
|
|
FdSink sink(STDOUT_FILENO);
|
2003-10-08 15:06:59 +00:00
|
|
|
|
string path = *opArgs.begin();
|
2003-06-23 14:08:34 +00:00
|
|
|
|
dumpPath(path, sink);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-05 22:57:07 +00:00
|
|
|
|
/* Restore a value from a Nix archive. The archive is read from
|
2003-06-23 14:08:34 +00:00
|
|
|
|
standard input. */
|
|
|
|
|
static void opRestore(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
|
|
|
|
if (opArgs.size() != 1) throw UsageError("only one argument allowed");
|
|
|
|
|
|
2006-11-30 19:19:59 +00:00
|
|
|
|
FdSource source(STDIN_FILENO);
|
2003-06-23 14:08:34 +00:00
|
|
|
|
restorePath(*opArgs.begin(), source);
|
2003-06-18 14:34:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2007-02-20 23:17:20 +00:00
|
|
|
|
static void opExport(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2007-02-21 14:31:42 +00:00
|
|
|
|
bool sign = false;
|
|
|
|
|
for (Strings::iterator i = opFlags.begin();
|
|
|
|
|
i != opFlags.end(); ++i)
|
|
|
|
|
if (*i == "--sign") sign = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2007-02-21 23:00:31 +00:00
|
|
|
|
|
2007-02-20 23:17:20 +00:00
|
|
|
|
FdSink sink(STDOUT_FILENO);
|
2013-05-23 18:55:36 +00:00
|
|
|
|
Paths sorted = topoSortPaths(*store, PathSet(opArgs.begin(), opArgs.end()));
|
|
|
|
|
reverse(sorted.begin(), sorted.end());
|
|
|
|
|
exportPaths(*store, sorted, sign, sink);
|
2007-02-20 23:17:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2007-02-21 15:45:32 +00:00
|
|
|
|
static void opImport(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2007-11-16 16:10:27 +00:00
|
|
|
|
bool requireSignature = false;
|
2009-03-22 17:36:43 +00:00
|
|
|
|
foreach (Strings::iterator, i, opFlags)
|
2007-11-16 16:10:27 +00:00
|
|
|
|
if (*i == "--require-signature") requireSignature = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2007-02-21 15:45:32 +00:00
|
|
|
|
if (!opArgs.empty()) throw UsageError("no arguments expected");
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2007-02-21 15:45:32 +00:00
|
|
|
|
FdSource source(STDIN_FILENO);
|
2011-12-16 22:31:25 +00:00
|
|
|
|
Paths paths = store->importPaths(requireSignature, source);
|
|
|
|
|
|
|
|
|
|
foreach (Paths::iterator, i, paths)
|
|
|
|
|
cout << format("%1%\n") % *i << std::flush;
|
2007-02-21 15:45:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-06-17 21:12:58 +00:00
|
|
|
|
/* Initialise the Nix databases. */
|
|
|
|
|
static void opInit(Strings opFlags, Strings opArgs)
|
2003-05-26 09:44:18 +00:00
|
|
|
|
{
|
2003-06-17 21:12:58 +00:00
|
|
|
|
if (!opFlags.empty()) throw UsageError("unknown flag");
|
|
|
|
|
if (!opArgs.empty())
|
2004-06-20 19:17:54 +00:00
|
|
|
|
throw UsageError("no arguments expected");
|
2006-11-30 17:43:04 +00:00
|
|
|
|
/* Doesn't do anything right now; database tables are initialised
|
|
|
|
|
automatically. */
|
2003-03-21 15:53:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-07-17 12:27:55 +00:00
|
|
|
|
/* Verify the consistency of the Nix environment. */
|
|
|
|
|
static void opVerify(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2005-02-08 13:48:53 +00:00
|
|
|
|
if (!opArgs.empty())
|
|
|
|
|
throw UsageError("no arguments expected");
|
|
|
|
|
|
|
|
|
|
bool checkContents = false;
|
2012-10-02 19:04:59 +00:00
|
|
|
|
bool repair = false;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2005-02-08 13:48:53 +00:00
|
|
|
|
for (Strings::iterator i = opFlags.begin();
|
|
|
|
|
i != opFlags.end(); ++i)
|
|
|
|
|
if (*i == "--check-contents") checkContents = true;
|
2012-10-02 19:04:59 +00:00
|
|
|
|
else if (*i == "--repair") repair = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2012-10-02 19:04:59 +00:00
|
|
|
|
if (ensureLocalStore().verifyStore(checkContents, repair)) {
|
|
|
|
|
printMsg(lvlError, "warning: not all errors were fixed");
|
2014-08-13 01:50:44 +00:00
|
|
|
|
throw Exit(1);
|
2012-10-02 19:04:59 +00:00
|
|
|
|
}
|
2003-07-17 12:27:55 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-09-06 12:06:30 +00:00
|
|
|
|
/* 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");
|
|
|
|
|
|
2014-08-13 01:50:44 +00:00
|
|
|
|
int status = 0;
|
|
|
|
|
|
2011-09-06 12:06:30 +00:00
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
|
|
|
|
Path path = followLinksToStorePath(*i);
|
2014-08-20 15:00:17 +00:00
|
|
|
|
printMsg(lvlTalkative, format("checking path ‘%1%’...") % path);
|
2011-09-06 12:06:30 +00:00
|
|
|
|
ValidPathInfo info = store->queryPathInfo(path);
|
|
|
|
|
HashResult current = hashPath(info.hash.type, path);
|
|
|
|
|
if (current.first != info.hash) {
|
|
|
|
|
printMsg(lvlError,
|
2014-08-20 15:00:17 +00:00
|
|
|
|
format("path ‘%1%’ was modified! expected hash ‘%2%’, got ‘%3%’")
|
2011-09-06 12:06:30 +00:00
|
|
|
|
% path % printHash(info.hash) % printHash(current.first));
|
2014-08-13 01:50:44 +00:00
|
|
|
|
status = 1;
|
2011-09-06 12:06:30 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-08-13 01:50:44 +00:00
|
|
|
|
|
|
|
|
|
throw Exit(status);
|
2011-09-06 12:06:30 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-02 18:08:59 +00:00
|
|
|
|
/* 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");
|
|
|
|
|
|
|
|
|
|
foreach (Strings::iterator, i, opArgs) {
|
|
|
|
|
Path path = followLinksToStorePath(*i);
|
|
|
|
|
ensureLocalStore().repairPath(path);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-09 22:14:27 +00:00
|
|
|
|
/* Optimise the disk space usage of the Nix store by hard-linking
|
|
|
|
|
files with the same contents. */
|
|
|
|
|
static void opOptimise(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2012-07-23 16:08:34 +00:00
|
|
|
|
if (!opArgs.empty() || !opFlags.empty())
|
2007-10-09 22:14:27 +00:00
|
|
|
|
throw UsageError("no arguments expected");
|
|
|
|
|
|
2014-09-01 20:21:42 +00:00
|
|
|
|
store->optimiseStore();
|
2007-10-09 22:14:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-04-26 12:56:42 +00:00
|
|
|
|
static void opQueryFailedPaths(Strings opFlags, Strings opArgs)
|
2010-04-26 12:43:42 +00:00
|
|
|
|
{
|
|
|
|
|
if (!opArgs.empty() || !opFlags.empty())
|
|
|
|
|
throw UsageError("no arguments expected");
|
2010-05-04 10:45:10 +00:00
|
|
|
|
PathSet failed = store->queryFailedPaths();
|
2010-04-26 12:43:42 +00:00
|
|
|
|
foreach (PathSet::iterator, i, failed)
|
|
|
|
|
cout << format("%1%\n") % *i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-26 12:56:42 +00:00
|
|
|
|
static void opClearFailedPaths(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
if (!opFlags.empty())
|
|
|
|
|
throw UsageError("no flags expected");
|
2010-05-04 10:45:10 +00:00
|
|
|
|
store->clearFailedPaths(PathSet(opArgs.begin(), opArgs.end()));
|
2010-04-26 12:56:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-02-14 10:48:42 +00:00
|
|
|
|
/* Serve the nix store in a way usable by a restricted ssh user. */
|
2014-02-06 16:52:03 +00:00
|
|
|
|
static void opServe(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
2014-07-10 09:51:22 +00:00
|
|
|
|
bool writeAllowed = false;
|
|
|
|
|
foreach (Strings::iterator, i, opFlags)
|
|
|
|
|
if (*i == "--write") writeAllowed = true;
|
2014-08-20 15:00:17 +00:00
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % *i);
|
2014-07-10 09:51:22 +00:00
|
|
|
|
|
|
|
|
|
if (!opArgs.empty()) throw UsageError("no arguments expected");
|
2014-02-10 11:52:48 +00:00
|
|
|
|
|
2014-02-06 16:52:03 +00:00
|
|
|
|
FdSource in(STDIN_FILENO);
|
|
|
|
|
FdSink out(STDOUT_FILENO);
|
|
|
|
|
|
2014-02-10 12:43:13 +00:00
|
|
|
|
/* Exchange the greeting. */
|
|
|
|
|
unsigned int magic = readInt(in);
|
|
|
|
|
if (magic != SERVE_MAGIC_1) throw Error("protocol mismatch");
|
|
|
|
|
writeInt(SERVE_MAGIC_2, out);
|
|
|
|
|
writeInt(SERVE_PROTOCOL_VERSION, out);
|
|
|
|
|
out.flush();
|
|
|
|
|
readInt(in); // Client version, unused for now
|
|
|
|
|
|
2014-07-10 09:51:22 +00:00
|
|
|
|
while (true) {
|
|
|
|
|
ServeCommand cmd;
|
|
|
|
|
try {
|
|
|
|
|
cmd = (ServeCommand) readInt(in);
|
|
|
|
|
} catch (EndOfFile & e) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (cmd) {
|
2014-07-10 18:43:04 +00:00
|
|
|
|
|
2014-07-10 09:51:22 +00:00
|
|
|
|
case cmdQueryValidPaths: {
|
|
|
|
|
bool lock = readInt(in);
|
2014-07-10 18:43:04 +00:00
|
|
|
|
bool substitute = readInt(in);
|
2014-07-10 09:51:22 +00:00
|
|
|
|
PathSet paths = readStorePaths<PathSet>(in);
|
|
|
|
|
if (lock && writeAllowed)
|
|
|
|
|
for (auto & path : paths)
|
|
|
|
|
store->addTempRoot(path);
|
2014-07-10 18:43:04 +00:00
|
|
|
|
|
|
|
|
|
/* If requested, substitute missing paths. This
|
|
|
|
|
implements nix-copy-closure's --use-substitutes
|
|
|
|
|
flag. */
|
|
|
|
|
if (substitute && writeAllowed) {
|
|
|
|
|
/* Filter out .drv files (we don't want to build anything). */
|
|
|
|
|
PathSet paths2;
|
|
|
|
|
for (auto & path : paths)
|
|
|
|
|
if (!isDerivation(path)) paths2.insert(path);
|
|
|
|
|
unsigned long long downloadSize, narSize;
|
|
|
|
|
PathSet willBuild, willSubstitute, unknown;
|
|
|
|
|
queryMissing(*store, PathSet(paths2.begin(), paths2.end()),
|
|
|
|
|
willBuild, willSubstitute, unknown, downloadSize, narSize);
|
|
|
|
|
/* FIXME: should use ensurePath(), but it only
|
|
|
|
|
does one path at a time. */
|
|
|
|
|
if (!willSubstitute.empty())
|
|
|
|
|
try {
|
|
|
|
|
store->buildPaths(willSubstitute);
|
|
|
|
|
} catch (Error & e) {
|
|
|
|
|
printMsg(lvlError, format("warning: %1%") % e.msg());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-10 09:51:22 +00:00
|
|
|
|
writeStrings(store->queryValidPaths(paths), out);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-07-10 18:43:04 +00:00
|
|
|
|
|
2014-07-10 09:51:22 +00:00
|
|
|
|
case cmdQueryPathInfos: {
|
|
|
|
|
PathSet paths = readStorePaths<PathSet>(in);
|
|
|
|
|
// !!! Maybe we want a queryPathInfos?
|
|
|
|
|
foreach (PathSet::iterator, i, paths) {
|
|
|
|
|
if (!store->isValidPath(*i))
|
|
|
|
|
continue;
|
|
|
|
|
ValidPathInfo info = store->queryPathInfo(*i);
|
|
|
|
|
writeString(info.path, out);
|
|
|
|
|
writeString(info.deriver, out);
|
|
|
|
|
writeStrings(info.references, out);
|
|
|
|
|
// !!! Maybe we want compression?
|
|
|
|
|
writeLongLong(info.narSize, out); // downloadSize
|
|
|
|
|
writeLongLong(info.narSize, out);
|
2014-02-10 12:43:13 +00:00
|
|
|
|
}
|
2014-07-10 09:51:22 +00:00
|
|
|
|
writeString("", out);
|
|
|
|
|
break;
|
2014-02-10 12:43:13 +00:00
|
|
|
|
}
|
2014-07-10 18:43:04 +00:00
|
|
|
|
|
2014-07-10 09:51:22 +00:00
|
|
|
|
case cmdDumpStorePath:
|
|
|
|
|
dumpPath(readStorePath(in), out);
|
|
|
|
|
break;
|
2014-07-10 18:43:04 +00:00
|
|
|
|
|
2014-07-10 12:15:12 +00:00
|
|
|
|
case cmdImportPaths: {
|
2014-07-11 14:02:19 +00:00
|
|
|
|
if (!writeAllowed) throw Error("importing paths is not allowed");
|
2014-07-24 15:11:54 +00:00
|
|
|
|
store->importPaths(false, in);
|
2014-07-10 09:51:22 +00:00
|
|
|
|
writeInt(1, out); // indicate success
|
|
|
|
|
break;
|
2014-07-10 12:15:12 +00:00
|
|
|
|
}
|
2014-07-10 18:43:04 +00:00
|
|
|
|
|
2014-07-11 14:02:19 +00:00
|
|
|
|
case cmdExportPaths: {
|
2014-07-24 14:00:29 +00:00
|
|
|
|
bool sign = readInt(in);
|
2014-07-14 10:19:27 +00:00
|
|
|
|
Paths sorted = topoSortPaths(*store, readStorePaths<PathSet>(in));
|
|
|
|
|
reverse(sorted.begin(), sorted.end());
|
2014-07-24 14:00:29 +00:00
|
|
|
|
exportPaths(*store, sorted, sign, out);
|
2014-07-11 14:02:19 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case cmdBuildPaths: {
|
2014-07-24 09:52:52 +00:00
|
|
|
|
|
2014-07-11 14:02:19 +00:00
|
|
|
|
/* Used by build-remote.pl. */
|
|
|
|
|
if (!writeAllowed) throw Error("building paths is not allowed");
|
|
|
|
|
PathSet paths = readStorePaths<PathSet>(in);
|
|
|
|
|
|
|
|
|
|
// 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);
|
|
|
|
|
|
|
|
|
|
try {
|
2014-07-24 09:52:52 +00:00
|
|
|
|
MonitorFdHup monitor(in.fd);
|
2014-07-11 14:02:19 +00:00
|
|
|
|
store->buildPaths(paths);
|
2014-07-24 10:43:59 +00:00
|
|
|
|
writeInt(0, out);
|
2014-07-11 14:02:19 +00:00
|
|
|
|
} catch (Error & e) {
|
2014-07-24 10:43:59 +00:00
|
|
|
|
assert(e.status);
|
|
|
|
|
writeInt(e.status, out);
|
|
|
|
|
writeString(e.msg(), out);
|
2014-07-11 14:02:19 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-24 14:00:29 +00:00
|
|
|
|
case cmdQueryClosure: {
|
|
|
|
|
bool includeOutputs = readInt(in);
|
|
|
|
|
PathSet paths = readStorePaths<PathSet>(in);
|
|
|
|
|
PathSet closure;
|
|
|
|
|
for (auto & i : paths)
|
|
|
|
|
computeFSClosure(*store, i, closure, false, includeOutputs);
|
|
|
|
|
writeStrings(closure, out);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-10 09:51:22 +00:00
|
|
|
|
default:
|
|
|
|
|
throw Error(format("unknown serve command %1%") % cmd);
|
|
|
|
|
}
|
2014-07-11 14:02:19 +00:00
|
|
|
|
|
|
|
|
|
out.flush();
|
2014-02-10 12:43:13 +00:00
|
|
|
|
}
|
2014-02-06 16:52:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-02-04 15:43:32 +00:00
|
|
|
|
static void opGenerateBinaryCacheKey(Strings opFlags, Strings opArgs)
|
|
|
|
|
{
|
|
|
|
|
foreach (Strings::iterator, i, opFlags)
|
|
|
|
|
throw UsageError(format("unknown flag ‘%1%’") % *i);
|
|
|
|
|
|
2015-02-18 10:19:44 +00:00
|
|
|
|
if (opArgs.size() != 3) throw UsageError("three arguments expected");
|
|
|
|
|
auto i = opArgs.begin();
|
|
|
|
|
string keyName = *i++;
|
|
|
|
|
string secretKeyFile = *i++;
|
|
|
|
|
string publicKeyFile = *i++;
|
2015-02-04 15:43:32 +00:00
|
|
|
|
|
2015-02-10 10:54:06 +00:00
|
|
|
|
#if HAVE_SODIUM
|
2015-02-04 15:43:32 +00:00
|
|
|
|
sodium_init();
|
|
|
|
|
|
|
|
|
|
unsigned char pk[crypto_sign_PUBLICKEYBYTES];
|
|
|
|
|
unsigned char sk[crypto_sign_SECRETKEYBYTES];
|
|
|
|
|
if (crypto_sign_keypair(pk, sk) != 0)
|
|
|
|
|
throw Error("key generation failed");
|
|
|
|
|
|
2015-02-18 10:19:44 +00:00
|
|
|
|
writeFile(publicKeyFile, keyName + ":" + base64Encode(string((char *) pk, crypto_sign_PUBLICKEYBYTES)));
|
|
|
|
|
umask(0077);
|
|
|
|
|
writeFile(secretKeyFile, keyName + ":" + base64Encode(string((char *) sk, crypto_sign_SECRETKEYBYTES)));
|
2015-02-10 10:54:06 +00:00
|
|
|
|
#else
|
|
|
|
|
throw Error("Nix was not compiled with libsodium, required for signed binary cache support");
|
|
|
|
|
#endif
|
2015-02-04 15:43:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-07-04 15:42:03 +00:00
|
|
|
|
/* Scan the arguments; find the operation, set global flags, put all
|
|
|
|
|
other flags in a list, and put all other arguments in another
|
|
|
|
|
list. */
|
2014-08-13 01:50:44 +00:00
|
|
|
|
int main(int argc, char * * argv)
|
2003-03-24 17:49:56 +00:00
|
|
|
|
{
|
2014-08-13 01:50:44 +00:00
|
|
|
|
return handleExceptions(argv[0], [&]() {
|
|
|
|
|
initNix();
|
|
|
|
|
|
|
|
|
|
Strings opFlags, opArgs;
|
|
|
|
|
Operation op = 0;
|
|
|
|
|
|
|
|
|
|
parseCmdLine(argc, argv, [&](Strings::iterator & arg, const Strings::iterator & end) {
|
|
|
|
|
Operation oldOp = op;
|
|
|
|
|
|
|
|
|
|
if (*arg == "--help")
|
|
|
|
|
showManPage("nix-store");
|
|
|
|
|
else if (*arg == "--version")
|
|
|
|
|
printVersion("nix-store");
|
|
|
|
|
else if (*arg == "--realise" || *arg == "--realize" || *arg == "-r")
|
|
|
|
|
op = opRealise;
|
|
|
|
|
else if (*arg == "--add" || *arg == "-A")
|
|
|
|
|
op = opAdd;
|
|
|
|
|
else if (*arg == "--add-fixed")
|
|
|
|
|
op = opAddFixed;
|
|
|
|
|
else if (*arg == "--print-fixed-path")
|
|
|
|
|
op = opPrintFixedPath;
|
|
|
|
|
else if (*arg == "--delete")
|
|
|
|
|
op = opDelete;
|
|
|
|
|
else if (*arg == "--query" || *arg == "-q")
|
|
|
|
|
op = opQuery;
|
|
|
|
|
else if (*arg == "--print-env")
|
|
|
|
|
op = opPrintEnv;
|
|
|
|
|
else if (*arg == "--read-log" || *arg == "-l")
|
|
|
|
|
op = opReadLog;
|
|
|
|
|
else if (*arg == "--dump-db")
|
|
|
|
|
op = opDumpDB;
|
|
|
|
|
else if (*arg == "--load-db")
|
|
|
|
|
op = opLoadDB;
|
|
|
|
|
else if (*arg == "--register-validity")
|
|
|
|
|
op = opRegisterValidity;
|
|
|
|
|
else if (*arg == "--check-validity")
|
|
|
|
|
op = opCheckValidity;
|
|
|
|
|
else if (*arg == "--gc")
|
|
|
|
|
op = opGC;
|
|
|
|
|
else if (*arg == "--dump")
|
|
|
|
|
op = opDump;
|
|
|
|
|
else if (*arg == "--restore")
|
|
|
|
|
op = opRestore;
|
|
|
|
|
else if (*arg == "--export")
|
|
|
|
|
op = opExport;
|
|
|
|
|
else if (*arg == "--import")
|
|
|
|
|
op = opImport;
|
|
|
|
|
else if (*arg == "--init")
|
|
|
|
|
op = opInit;
|
|
|
|
|
else if (*arg == "--verify")
|
|
|
|
|
op = opVerify;
|
|
|
|
|
else if (*arg == "--verify-path")
|
|
|
|
|
op = opVerifyPath;
|
|
|
|
|
else if (*arg == "--repair-path")
|
|
|
|
|
op = opRepairPath;
|
|
|
|
|
else if (*arg == "--optimise" || *arg == "--optimize")
|
|
|
|
|
op = opOptimise;
|
|
|
|
|
else if (*arg == "--query-failed-paths")
|
|
|
|
|
op = opQueryFailedPaths;
|
|
|
|
|
else if (*arg == "--clear-failed-paths")
|
|
|
|
|
op = opClearFailedPaths;
|
2015-02-04 15:43:32 +00:00
|
|
|
|
else if (*arg == "--serve")
|
|
|
|
|
op = opServe;
|
|
|
|
|
else if (*arg == "--generate-binary-cache-key")
|
|
|
|
|
op = opGenerateBinaryCacheKey;
|
2014-08-13 01:50:44 +00:00
|
|
|
|
else if (*arg == "--add-root")
|
|
|
|
|
gcRoot = absPath(getArg(*arg, arg, end));
|
|
|
|
|
else if (*arg == "--indirect")
|
|
|
|
|
indirectRoot = true;
|
|
|
|
|
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));
|
2008-06-18 14:20:16 +00:00
|
|
|
|
}
|
2014-08-13 01:50:44 +00:00
|
|
|
|
else
|
|
|
|
|
opArgs.push_back(*arg);
|
2003-05-25 22:42:19 +00:00
|
|
|
|
|
2014-08-13 01:50:44 +00:00
|
|
|
|
if (oldOp && oldOp != op)
|
|
|
|
|
throw UsageError("only one operation may be specified");
|
2003-03-20 16:53:00 +00:00
|
|
|
|
|
2014-08-13 01:50:44 +00:00
|
|
|
|
return true;
|
|
|
|
|
});
|
2003-10-14 15:33:00 +00:00
|
|
|
|
|
2014-08-13 01:50:44 +00:00
|
|
|
|
if (!op) throw UsageError("no operation specified");
|
2003-03-14 16:43:14 +00:00
|
|
|
|
|
2014-08-13 01:50:44 +00:00
|
|
|
|
if (op != opDump && op != opRestore) /* !!! hack */
|
|
|
|
|
store = openStore(op != opGC);
|
2003-03-24 17:49:56 +00:00
|
|
|
|
|
2014-08-13 01:50:44 +00:00
|
|
|
|
op(opFlags, opArgs);
|
|
|
|
|
});
|
|
|
|
|
}
|