guix/src/nix.cc

393 lines
11 KiB
C++
Raw Normal View History

2003-03-13 16:28:32 +00:00
#include <iostream>
#include <sstream>
#include "globals.hh"
2003-07-20 19:29:38 +00:00
#include "normalise.hh"
#include "archive.hh"
#include "shared.hh"
2003-03-24 11:50:20 +00:00
typedef void (* Operation) (Strings opFlags, Strings opArgs);
static bool pathArgs = false;
static void printHelp()
{
cout <<
#include "nix-help.txt.hh"
;
exit(0);
}
2003-07-15 22:28:27 +00:00
static FSId argToId(const string & arg)
{
if (!pathArgs)
return parseHash(arg);
else {
2003-07-15 22:28:27 +00:00
FSId id;
if (!queryPathId(arg, id))
throw Error(format("don't know id of `%1%'") % arg);
2003-07-15 22:28:27 +00:00
return id;
}
}
/* Realise (or install) paths from the given Nix fstate
expressions. */
2003-07-07 09:29:40 +00:00
static void opInstall(Strings opFlags, Strings opArgs)
{
if (!opFlags.empty()) throw UsageError("unknown flag");
2003-03-13 16:28:32 +00:00
for (Strings::iterator it = opArgs.begin();
it != opArgs.end(); it++)
{
FSId id = normaliseFState(argToId(*it));
realiseSlice(id);
cout << format("%1%\n") % (string) id;
}
}
/* Delete a path in the Nix store directory. */
static void opDelete(Strings opFlags, Strings opArgs)
{
2003-06-23 14:40:49 +00:00
if (!opFlags.empty()) throw UsageError("unknown flag");
2003-06-23 14:40:49 +00:00
for (Strings::iterator it = opArgs.begin();
it != opArgs.end(); it++)
deleteFromStore(absPath(*it));
}
/* Add paths to the Nix values directory and print the hashes of those
paths. */
static void opAdd(Strings opFlags, Strings opArgs)
{
if (!opFlags.empty()) throw UsageError("unknown flag");
for (Strings::iterator it = opArgs.begin();
it != opArgs.end(); it++)
2003-07-04 12:18:06 +00:00
{
string path;
2003-07-15 22:28:27 +00:00
FSId id;
addToStore(*it, path, id);
cout << format("%1% %2%\n") % (string) id % path;
2003-07-04 12:18:06 +00:00
}
2003-03-13 16:28:32 +00:00
}
static string dotQuote(const string & s)
{
return "\"" + s + "\"";
}
FSId maybeNormalise(const FSId & id, bool normalise)
{
return normalise ? normaliseFState(id) : id;
}
/* Perform various sorts of queries. */
static void opQuery(Strings opFlags, Strings opArgs)
{
enum { qList, qRequisites, qGenerators, qExpansion, qGraph
} query = qList;
bool normalise = false;
bool includeExprs = true;
bool includeSuccessors = false;
for (Strings::iterator i = opFlags.begin();
i != opFlags.end(); i++)
if (*i == "--list" || *i == "-l") query = qList;
else if (*i == "--requisites" || *i == "-r") query = qRequisites;
else if (*i == "--generators" || *i == "-g") query = qGenerators;
else if (*i == "--expansion" || *i == "-e") query = qExpansion;
else if (*i == "--graph") query = qGraph;
else if (*i == "--normalise" || *i == "-n") normalise = true;
else if (*i == "--exclude-exprs") includeExprs = false;
else if (*i == "--include-successors") includeSuccessors = true;
else throw UsageError(format("unknown flag `%1%'") % *i);
switch (query) {
case qList: {
StringSet paths;
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); i++)
{
Strings paths2 = fstatePaths(
maybeNormalise(argToId(*i), normalise));
paths.insert(paths2.begin(), paths2.end());
}
for (StringSet::iterator i = paths.begin();
i != paths.end(); i++)
cout << format("%s\n") % *i;
break;
}
case qRequisites: {
StringSet paths;
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); i++)
{
Strings paths2 = fstateRequisites(
maybeNormalise(argToId(*i), normalise),
includeExprs, includeSuccessors);
paths.insert(paths2.begin(), paths2.end());
}
for (StringSet::iterator i = paths.begin();
i != paths.end(); i++)
cout << format("%s\n") % *i;
break;
}
case qGenerators: {
FSIds outIds;
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); i++)
outIds.push_back(argToId(*i));
FSIds genIds = findGenerators(outIds);
for (FSIds::iterator i = genIds.begin();
i != genIds.end(); i++)
cout << format("%s\n") % expandId(*i);
break;
}
case qExpansion: {
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); i++)
/* !!! should not use substitutes; this is a query,
it should not have side-effects */
cout << format("%s\n") % expandId(parseHash(*i));
break;
}
case qGraph: {
FSIds workList;
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); i++)
workList.push_back(argToId(*i));
FSIdSet doneSet;
cout << "digraph G {\n";
while (!workList.empty()) {
FSId id = workList.front();
workList.pop_front();
if (doneSet.find(id) == doneSet.end()) {
doneSet.insert(id);
FState fs = parseFState(termFromId(id));
2003-07-29 10:53:27 +00:00
string label, shape;
if (fs.type == FState::fsDerive) {
for (FSIds::iterator i = fs.derive.inputs.begin();
i != fs.derive.inputs.end(); i++)
{
workList.push_back(*i);
cout << dotQuote(*i) << " -> "
<< dotQuote(id) << ";\n";
}
label = "derive";
2003-07-29 10:53:27 +00:00
shape = "box";
for (StringPairs::iterator i = fs.derive.env.begin();
i != fs.derive.env.end(); i++)
if (i->first == "name") label = i->second;
}
else if (fs.type == FState::fsSlice) {
label = baseNameOf((*fs.slice.elems.begin()).path);
2003-07-29 10:53:27 +00:00
shape = "ellipse";
if (isHash(string(label, 0, Hash::hashSize * 2)) &&
label[Hash::hashSize * 2] == '-')
label = string(label, Hash::hashSize * 2 + 1);
}
else abort();
cout << dotQuote(id) << "[label = "
<< dotQuote(label)
2003-07-29 10:53:27 +00:00
<< ", shape = " << shape
<< "];\n";
}
}
cout << "}\n";
break;
}
default:
abort();
}
}
static void opSuccessor(Strings opFlags, Strings opArgs)
{
if (!opFlags.empty()) throw UsageError("unknown flag");
if (opArgs.size() % 2) throw UsageError("expecting even number of arguments");
Transaction txn(nixDB); /* !!! this could be a big transaction */
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); )
{
2003-07-15 22:28:27 +00:00
FSId id1 = parseHash(*i++);
FSId id2 = parseHash(*i++);
registerSuccessor(txn, id1, id2);
}
txn.commit();
}
static void opSubstitute(Strings opFlags, Strings opArgs)
{
if (!opFlags.empty()) throw UsageError("unknown flag");
if (opArgs.size() % 2) throw UsageError("expecting even number of arguments");
for (Strings::iterator i = opArgs.begin();
i != opArgs.end(); )
{
2003-07-15 22:28:27 +00:00
FSId src = parseHash(*i++);
FSId sub = parseHash(*i++);
registerSubstitute(src, sub);
}
}
2003-06-18 14:34:43 +00:00
/* A sink that writes dump output to stdout. */
struct StdoutSink : DumpSink
{
virtual void operator ()
(const unsigned char * data, unsigned int len)
{
writeFull(STDOUT_FILENO, data, len);
2003-06-18 14:34:43 +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");
StdoutSink sink;
string arg = *opArgs.begin();
string path = pathArgs ? arg : expandId(parseHash(arg));
2003-06-23 14:08:34 +00:00
dumpPath(path, sink);
}
/* A source that read restore intput to stdin. */
struct StdinSource : RestoreSource
{
virtual void operator () (unsigned char * data, unsigned int len)
2003-06-23 14:08:34 +00:00
{
readFull(STDIN_FILENO, data, len);
2003-06-23 14:08:34 +00:00
}
};
/* Restore a value from a Nix archive. The archive is written to
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");
StdinSource source;
restorePath(*opArgs.begin(), source);
2003-06-18 14:34:43 +00:00
}
/* Initialise the Nix databases. */
static void opInit(Strings opFlags, Strings opArgs)
{
if (!opFlags.empty()) throw UsageError("unknown flag");
if (!opArgs.empty())
throw UsageError("--init does not have arguments");
initDB();
}
/* Verify the consistency of the Nix environment. */
static void opVerify(Strings opFlags, Strings opArgs)
{
verifyStore();
}
/* Scan the arguments; find the operation, set global flags, put all
other flags in a list, and put all other arguments in another
list. */
void run(Strings args)
{
openDB();
Strings opFlags, opArgs;
Operation op = 0;
for (Strings::iterator it = args.begin(); it != args.end(); )
{
string arg = *it++;
Operation oldOp = op;
2003-07-07 09:29:40 +00:00
if (arg == "--install" || arg == "-i")
op = opInstall;
else if (arg == "--delete" || arg == "-d")
op = opDelete;
else if (arg == "--add" || arg == "-A")
op = opAdd;
else if (arg == "--query" || arg == "-q")
op = opQuery;
else if (arg == "--successor")
op = opSuccessor;
else if (arg == "--substitute")
op = opSubstitute;
2003-06-18 14:34:43 +00:00
else if (arg == "--dump")
op = opDump;
2003-06-23 14:08:34 +00:00
else if (arg == "--restore")
op = opRestore;
else if (arg == "--init")
op = opInit;
else if (arg == "--verify")
op = opVerify;
else if (arg == "--path" || arg == "-p")
pathArgs = true;
else if (arg == "--verbose" || arg == "-v")
verbosity = (Verbosity) ((int) verbosity + 1);
else if (arg == "--help")
printHelp();
else if (arg[0] == '-')
opFlags.push_back(arg);
else
opArgs.push_back(arg);
if (oldOp && oldOp != op)
throw UsageError("only one operation may be specified");
}
if (!op) throw UsageError("no operation specified");
2003-03-20 16:53:00 +00:00
op(opFlags, opArgs);
2003-03-20 16:53:00 +00:00
}
string programId = "nix";