lix/src/nix.cc

343 lines
8.6 KiB
C++
Raw Normal View History

2003-03-13 16:28:32 +00:00
#include <iostream>
#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);
typedef enum { atpHash, atpPath, atpUnknown } ArgType;
static ArgType argType = atpUnknown;
/* Nix syntax:
nix [OPTIONS...] [ARGUMENTS...]
Operations:
--install / -i: realise an fstate
--delete / -d: delete paths from the Nix store
--add / -A: copy a path to the Nix store
--query / -q: query information
2003-06-23 14:08:34 +00:00
--successor: register a successor expression
--substitute: register a substitute expression
--dump: dump a path as a Nix archive
--restore: restore a path from a Nix archive
2003-06-23 14:08:34 +00:00
--init: initialise the Nix database
2003-06-23 14:08:34 +00:00
--verify: verify Nix structures
--version: output version information
--help: display help
Source selection for --install, --dump:
--file / -f: by file name !!! -> path
2003-07-15 22:28:27 +00:00
--hash / -h: by hash (identifier)
Query flags:
--path / -p: query the path of an fstate
--refs / -r: query paths referenced by an fstate
Options:
--verbose / -v: verbose operation
*/
/* Parse the `-f' / `-h' / flags, i.e., the type of arguments. These
flags are deleted from the referenced vector. */
2003-06-25 14:58:56 +00:00
static void getArgType(Strings & flags)
{
for (Strings::iterator it = flags.begin();
it != flags.end(); )
{
string arg = *it;
ArgType tp;
if (arg == "--hash" || arg == "-h") tp = atpHash;
else if (arg == "--file" || arg == "-f") tp = atpPath;
else { it++; continue; }
if (argType != atpUnknown)
throw UsageError("only one argument type specified may be specified");
argType = tp;
it = flags.erase(it);
2003-03-20 16:53:00 +00:00
}
if (argType == atpUnknown)
throw UsageError("argument type not specified");
}
2003-03-13 16:28:32 +00:00
2003-07-15 22:28:27 +00:00
static FSId argToId(const string & arg)
{
if (argType == atpHash)
return parseHash(arg);
else if (argType == atpPath) {
string path;
2003-07-15 22:28:27 +00:00
FSId id;
addToStore(arg, path, id);
return id;
}
else abort();
}
/* 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)
{
getArgType(opFlags);
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++)
2003-07-15 22:28:27 +00:00
realiseSlice(normaliseFState(argToId(*it)));
}
/* 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)
{
getArgType(opFlags);
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
}
/* Perform various sorts of queries. */
static void opQuery(Strings opFlags, Strings opArgs)
{
enum { qPath, qRefs, qUnknown } query = qPath;
for (Strings::iterator it = opFlags.begin();
it != opFlags.end(); )
{
string arg = *it;
if (arg == "--path" || arg == "-p") query = qPath;
else if (arg == "--refs" || arg == "-r") query = qRefs;
else { it++; continue; }
it = opFlags.erase(it);
}
getArgType(opFlags);
if (!opFlags.empty()) throw UsageError("unknown flag");
for (Strings::iterator it = opArgs.begin();
it != opArgs.end(); it++)
{
2003-07-15 22:28:27 +00:00
FSId id = argToId(*it);
switch (query) {
case qPath: {
Strings paths = fstatePaths(id, true);
2003-07-16 11:05:59 +00:00
for (Strings::iterator j = paths.begin();
j != paths.end(); j++)
cout << format("%s\n") % *j;
break;
}
case qRefs: {
2003-07-16 11:05:59 +00:00
StringSet refs = fstateRefs(id);
for (StringSet::iterator j = refs.begin();
j != refs.end(); j++)
cout << format("%s\n") % *j;
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");
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(id1, id2);
}
}
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)
{
while (len) {
ssize_t res = write(STDOUT_FILENO, (char *) data, len);
if (res == -1) throw SysError("writing to stdout");
len -= res;
data += res;
}
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)
{
getArgType(opFlags);
2003-06-18 14:34:43 +00:00
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;
2003-07-15 22:28:27 +00:00
if (argType == atpHash) path = expandId(parseHash(arg));
else if (argType == atpPath) path = 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 () (const unsigned char * data, unsigned int len)
{
while (len) {
ssize_t res = read(STDIN_FILENO, (char *) data, len);
if (res == -1) throw SysError("reading from stdin");
if (res == 0) throw Error("unexpected end-of-file on stdin");
len -= res;
data += res;
}
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)
{
Strings opFlags, opArgs;
Operation op = 0;
for (Strings::iterator it = args.begin();
it != args.end(); it++)
{
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[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";