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
|
|
|
|
{
|
2015-05-13 16:03:22 +00:00
|
|
|
|
if (isDerivation(path)) return path;
|
|
|
|
|
Path drvPath = store->queryDeriver(path);
|
|
|
|
|
if (drvPath == "")
|
|
|
|
|
throw Error(format("deriver of path ‘%1%’ is not known") % path);
|
|
|
|
|
return drvPath;
|
2006-10-28 16:33:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
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())
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : drv.outputs) p.second.insert(i.first);
|
2012-11-26 14:39:10 +00:00
|
|
|
|
|
2011-12-30 17:25:19 +00:00
|
|
|
|
PathSet outputs;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & j : p.second) {
|
|
|
|
|
DerivationOutputs::iterator i = drv.outputs.find(j);
|
2012-11-26 14:39:10 +00:00
|
|
|
|
if (i == drv.outputs.end())
|
2015-07-17 17:24:28 +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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
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(format("unknown flag ‘%1%’") % i);
|
2003-03-13 16:28:32 +00:00
|
|
|
|
|
2012-11-19 23:27:25 +00:00
|
|
|
|
Paths paths;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
DrvPathWithOutputs p = parseDrvPathWithOutputs(i);
|
2012-11-26 14:39:10 +00:00
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : paths)
|
|
|
|
|
if (unknown.find(i) == unknown.end()) paths2.push_back(i);
|
2012-11-19 23:27:25 +00:00
|
|
|
|
paths = paths2;
|
|
|
|
|
unknown = PathSet();
|
|
|
|
|
}
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2015-03-04 14:43:04 +00:00
|
|
|
|
if (settings.get("print-missing", true))
|
|
|
|
|
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)
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : paths) {
|
|
|
|
|
PathSet paths = realisePath(i, false);
|
2013-12-20 12:10:14 +00:00
|
|
|
|
if (!noOutput)
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & 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
|
|
|
|
|
2015-03-25 16:06:12 +00:00
|
|
|
|
for (auto & i : opArgs)
|
|
|
|
|
cout << format("%1%\n") % store->addToStore(baseNameOf(i), 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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--recursive") recursive = true;
|
|
|
|
|
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();
|
|
|
|
|
|
2015-03-25 16:06:12 +00:00
|
|
|
|
for (auto & i : opArgs)
|
|
|
|
|
cout << format("%1%\n") % store->addToStore(baseNameOf(i), 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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto i : opFlags)
|
|
|
|
|
if (i == "--recursive") recursive = true;
|
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : drv.outputs)
|
|
|
|
|
outputs.insert(i.second.path);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
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());
|
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto i = sorted.begin(); i != sorted.end(); ++i) {
|
|
|
|
|
auto 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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags) {
|
2014-10-14 10:15:39 +00:00
|
|
|
|
QueryType prev = query;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
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 == "--binding" || i == "-b") {
|
2005-02-07 14:32:44 +00:00
|
|
|
|
if (opArgs.size() == 0)
|
|
|
|
|
throw UsageError("expected binding name");
|
|
|
|
|
bindingName = opArgs.front();
|
|
|
|
|
opArgs.pop_front();
|
|
|
|
|
query = qBinding;
|
|
|
|
|
}
|
2015-07-17 17:24:28 +00:00
|
|
|
|
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 == "--xml") query = qXml;
|
|
|
|
|
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(format("unknown flag ‘%1%’") % i);
|
2014-10-14 10:15:39 +00:00
|
|
|
|
if (prev != qDefault && prev != query)
|
2015-07-17 17:24:28 +00:00
|
|
|
|
throw UsageError(format("query type ‘%1%’ conflicts with earlier flag") % i);
|
2014-10-14 10:15:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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: {
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
i = followLinksToStorePath(i);
|
|
|
|
|
if (forceRealise) realisePath(i);
|
|
|
|
|
Derivation drv = derivationFromPath(*store, i);
|
|
|
|
|
for (auto & 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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
PathSet ps = maybeUseOutputs(followLinksToStorePath(i), useOutput, forceRealise);
|
|
|
|
|
for (auto & 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);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
}
|
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:
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
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:
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
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:
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(i), useOutput, forceRealise);
|
|
|
|
|
for (auto & j : paths) {
|
|
|
|
|
ValidPathInfo info = store->queryPathInfo(j);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs)
|
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(i), useOutput, forceRealise);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
roots.insert(paths.begin(), paths.end());
|
|
|
|
|
}
|
2010-05-31 16:36:24 +00:00
|
|
|
|
printDotGraph(roots);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case qXml: {
|
|
|
|
|
PathSet roots;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(i), useOutput, forceRealise);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
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: {
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs)
|
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
PathSet paths = maybeUseOutputs(followLinksToStorePath(i), useOutput, forceRealise);
|
|
|
|
|
for (auto & j : paths)
|
|
|
|
|
computeFSClosure(*store, j, referrers, true,
|
2012-12-20 17:41:44 +00:00
|
|
|
|
settings.gcKeepOutputs, settings.gcKeepDerivations);
|
2011-12-30 17:25:19 +00:00
|
|
|
|
}
|
2009-11-23 18:16:25 +00:00
|
|
|
|
Roots roots = store->findRoots();
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : roots)
|
|
|
|
|
if (referrers.find(i.second) != referrers.end())
|
|
|
|
|
cout << format("%1%\n") % i.first;
|
2009-11-23 18:16:25 +00:00
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : s)
|
|
|
|
|
if (i == '\'') r += "'\\''"; else r += i;
|
2012-01-17 23:07:22 +00:00
|
|
|
|
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. */
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : drv.env)
|
|
|
|
|
cout << format("export %1%; %1%='%2%'\n") % i.first % shellEscape(i.second);
|
2012-01-17 23:07:22 +00:00
|
|
|
|
|
|
|
|
|
/* Also output the arguments. This doesn't preserve whitespace in
|
|
|
|
|
arguments. */
|
|
|
|
|
cout << "export _args; _args='";
|
2015-07-17 17:24:28 +00:00
|
|
|
|
bool first = true;
|
|
|
|
|
for (auto & i : drv.args) {
|
|
|
|
|
if (!first) cout << ' ';
|
|
|
|
|
first = false;
|
|
|
|
|
cout << shellEscape(i);
|
2012-01-17 23:07:22 +00:00
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
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();
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & 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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--reregister") reregister = true;
|
|
|
|
|
else if (i == "--hash-given") hashGiven = true;
|
|
|
|
|
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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--print-invalid") printInvalid = true;
|
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % i);
|
2004-02-14 21:44:18 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
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? */
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto i = opFlags.begin(); i != opFlags.end(); ++i)
|
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();
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : roots)
|
|
|
|
|
cout << i.first << " -> " << i.second << std::endl;
|
2009-11-23 17:23:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else {
|
|
|
|
|
PrintFreed freed(options.action == GCOptions::gcDeleteDead, results);
|
|
|
|
|
store->collectGarbage(options, results);
|
|
|
|
|
|
|
|
|
|
if (options.action != GCOptions::gcDeleteDead)
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : results.paths)
|
|
|
|
|
cout << i << std::endl;
|
2009-11-23 17:23:12 +00:00
|
|
|
|
}
|
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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--ignore-liveness") options.ignoreLiveness = true;
|
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % i);
|
2005-12-23 21:08:42 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs)
|
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--sign") sign = true;
|
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--require-signature") requireSignature = true;
|
|
|
|
|
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);
|
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & 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
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--check-contents") checkContents = true;
|
|
|
|
|
else if (i == "--repair") repair = true;
|
|
|
|
|
else throw UsageError(format("unknown flag ‘%1%’") % i);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2015-06-02 00:21:15 +00:00
|
|
|
|
if (store->verifyStore(checkContents, repair)) {
|
2012-10-02 19:04:59 +00:00
|
|
|
|
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;
|
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & 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");
|
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opArgs) {
|
|
|
|
|
Path path = followLinksToStorePath(i);
|
2012-10-02 18:08:59 +00:00
|
|
|
|
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();
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : failed)
|
|
|
|
|
cout << format("%1%\n") % i;
|
2010-04-26 12:43:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
if (i == "--write") writeAllowed = true;
|
|
|
|
|
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
|
|
|
|
|
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
|
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);
|
|
|
|
|
};
|
|
|
|
|
|
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?
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : paths) {
|
|
|
|
|
if (!store->isValidPath(i))
|
2014-07-10 09:51:22 +00:00
|
|
|
|
continue;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
ValidPathInfo info = store->queryPathInfo(i);
|
2014-07-10 09:51:22 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
|
case cmdBuildPaths: { /* Used by build-remote.pl. */
|
2014-07-24 09:52:52 +00:00
|
|
|
|
|
2014-07-11 14:02:19 +00:00
|
|
|
|
if (!writeAllowed) throw Error("building paths is not allowed");
|
|
|
|
|
PathSet paths = readStorePaths<PathSet>(in);
|
|
|
|
|
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
|
getBuildSettings();
|
2014-07-11 14:02:19 +00:00
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
Allow remote builds without sending the derivation closure
Previously, to build a derivation remotely, we had to copy the entire
closure of the .drv file to the remote machine, even though we only
need the top-level derivation. This is very wasteful: the closure can
contain thousands of store paths, and in some Hydra use cases, include
source paths that are very large (e.g. Git/Mercurial checkouts).
So now there is a new operation, StoreAPI::buildDerivation(), that
performs a build from an in-memory representation of a derivation
(BasicDerivation) rather than from a on-disk .drv file. The only files
that need to be in the Nix store are the sources of the derivation
(drv.inputSrcs), and the needed output paths of the dependencies (as
described by drv.inputDrvs). "nix-store --serve" exposes this
interface.
Note that this is a privileged operation, because you can construct a
derivation that builds any store path whatsoever. Fixing this will
require changing the hashing scheme (i.e., the output paths should be
computed from the other fields in BasicDerivation, allowing them to be
verified without access to other derivations). However, this would be
quite nice because it would allow .drv-free building (e.g. "nix-env
-i" wouldn't have to write any .drv files to disk).
Fixes #173.
2015-07-17 15:57:40 +00:00
|
|
|
|
case cmdBuildDerivation: { /* Used by hydra-queue-runner. */
|
|
|
|
|
|
|
|
|
|
if (!writeAllowed) throw Error("building paths is not allowed");
|
|
|
|
|
|
|
|
|
|
Path drvPath = readStorePath(in); // informational only
|
|
|
|
|
BasicDerivation drv;
|
|
|
|
|
in >> drv;
|
|
|
|
|
|
|
|
|
|
getBuildSettings();
|
|
|
|
|
|
|
|
|
|
MonitorFdHup monitor(in.fd);
|
|
|
|
|
auto status = store->buildDerivation(drvPath, drv);
|
|
|
|
|
|
|
|
|
|
writeInt(status.status, out);
|
|
|
|
|
writeString(status.errorMsg, out);
|
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : opFlags)
|
|
|
|
|
throw UsageError(format("unknown flag ‘%1%’") % i);
|
2015-02-04 15:43:32 +00:00
|
|
|
|
|
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);
|
|
|
|
|
});
|
|
|
|
|
}
|