2003-06-23 15:27:59 +02:00
|
|
|
#include <iostream>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
|
2003-07-07 09:43:58 +02:00
|
|
|
#include "store.hh"
|
2003-06-16 15:33:38 +02:00
|
|
|
#include "globals.hh"
|
|
|
|
#include "db.hh"
|
2003-06-23 15:27:59 +02:00
|
|
|
#include "archive.hh"
|
2003-08-04 09:09:36 +02:00
|
|
|
#include "pathlocks.hh"
|
2003-06-23 15:27:59 +02:00
|
|
|
|
|
|
|
|
|
|
|
struct CopySink : DumpSink
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
virtual void operator () (const unsigned char * data, unsigned int len)
|
|
|
|
{
|
2003-07-20 23:11:43 +02:00
|
|
|
writeFull(fd, data, len);
|
2003-06-23 15:27:59 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct CopySource : RestoreSource
|
|
|
|
{
|
|
|
|
int fd;
|
2003-07-20 23:11:43 +02:00
|
|
|
virtual void operator () (unsigned char * data, unsigned int len)
|
2003-06-23 15:27:59 +02:00
|
|
|
{
|
2003-07-20 23:11:43 +02:00
|
|
|
readFull(fd, data, len);
|
2003-06-23 15:27:59 +02:00
|
|
|
}
|
|
|
|
};
|
2003-06-16 15:33:38 +02:00
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
void copyPath(const Path & src, const Path & dst)
|
2003-06-16 15:33:38 +02:00
|
|
|
{
|
2003-07-31 18:05:35 +02:00
|
|
|
debug(format("copying `%1%' to `%2%'") % src % dst);
|
|
|
|
|
2003-06-23 15:27:59 +02:00
|
|
|
/* Unfortunately C++ doesn't support coprocedures, so we have no
|
|
|
|
nice way to chain CopySink and CopySource together. Instead we
|
|
|
|
fork off a child to run the sink. (Fork-less platforms should
|
|
|
|
use a thread). */
|
|
|
|
|
|
|
|
/* Create a pipe. */
|
|
|
|
int fds[2];
|
|
|
|
if (pipe(fds) == -1) throw SysError("creating pipe");
|
|
|
|
|
|
|
|
/* Fork. */
|
|
|
|
pid_t pid;
|
|
|
|
switch (pid = fork()) {
|
|
|
|
|
|
|
|
case -1:
|
|
|
|
throw SysError("unable to fork");
|
|
|
|
|
|
|
|
case 0: /* child */
|
|
|
|
try {
|
|
|
|
close(fds[1]);
|
|
|
|
CopySource source;
|
|
|
|
source.fd = fds[0];
|
|
|
|
restorePath(dst, source);
|
|
|
|
_exit(0);
|
|
|
|
} catch (exception & e) {
|
|
|
|
cerr << "error: " << e.what() << endl;
|
|
|
|
}
|
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
close(fds[0]);
|
|
|
|
|
|
|
|
/* Parent. */
|
|
|
|
|
|
|
|
CopySink sink;
|
|
|
|
sink.fd = fds[1];
|
|
|
|
dumpPath(src, sink);
|
|
|
|
|
|
|
|
/* Wait for the child to finish. */
|
|
|
|
int status;
|
|
|
|
if (waitpid(pid, &status, 0) != pid)
|
|
|
|
throw SysError("waiting for child");
|
|
|
|
|
|
|
|
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
|
|
|
|
throw Error("cannot copy file: child died");
|
2003-06-16 15:33:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-10 16:46:28 +02:00
|
|
|
void registerSuccessor(const Transaction & txn,
|
2003-10-10 17:14:29 +02:00
|
|
|
const Path & srcPath, const Path & sucPath)
|
2003-10-10 16:46:28 +02:00
|
|
|
{
|
|
|
|
Path known;
|
2003-10-10 17:14:29 +02:00
|
|
|
if (nixDB.queryString(txn, dbSuccessors, srcPath, known) &&
|
|
|
|
known != sucPath)
|
2003-10-10 16:46:28 +02:00
|
|
|
{
|
|
|
|
throw Error(format(
|
|
|
|
"the `impossible' happened: expression in path "
|
|
|
|
"`%1%' appears to have multiple successors "
|
|
|
|
"(known `%2%', new `%3%'")
|
2003-10-10 17:14:29 +02:00
|
|
|
% srcPath % known % sucPath);
|
2003-10-10 16:46:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Paths revs;
|
2003-10-10 17:14:29 +02:00
|
|
|
nixDB.queryStrings(txn, dbSuccessorsRev, sucPath, revs);
|
|
|
|
revs.push_back(srcPath);
|
2003-10-10 16:46:28 +02:00
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
nixDB.setString(txn, dbSuccessors, srcPath, sucPath);
|
|
|
|
nixDB.setStrings(txn, dbSuccessorsRev, sucPath, revs);
|
2003-10-10 16:46:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-10 17:25:21 +02:00
|
|
|
Paths queryPredecessors(const Path & sucPath)
|
|
|
|
{
|
|
|
|
Paths revs;
|
|
|
|
nixDB.queryStrings(noTxn, dbSuccessorsRev, sucPath, revs);
|
|
|
|
return revs;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
void registerSubstitute(const Path & srcPath, const Path & subPath)
|
2003-07-10 17:11:48 +02:00
|
|
|
{
|
2003-10-10 16:46:28 +02:00
|
|
|
Transaction txn(nixDB);
|
2003-07-10 17:11:48 +02:00
|
|
|
|
2003-10-10 16:46:28 +02:00
|
|
|
Paths subs;
|
|
|
|
nixDB.queryStrings(txn, dbSubstitutes, srcPath, subs);
|
2003-07-16 22:00:51 +02:00
|
|
|
|
2003-10-10 16:46:28 +02:00
|
|
|
if (find(subs.begin(), subs.end(), subPath) != subs.end()) {
|
|
|
|
/* Nothing to do if the substitute is already known. */
|
|
|
|
txn.abort();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
subs.push_front(subPath); /* new substitutes take precedence */
|
|
|
|
|
|
|
|
Paths revs;
|
|
|
|
nixDB.queryStrings(txn, dbSubstitutesRev, subPath, revs);
|
|
|
|
revs.push_back(srcPath);
|
2003-07-31 18:05:35 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
nixDB.setStrings(txn, dbSubstitutes, srcPath, subs);
|
2003-10-10 16:46:28 +02:00
|
|
|
nixDB.setStrings(txn, dbSubstitutesRev, subPath, revs);
|
|
|
|
|
2003-07-31 18:05:35 +02:00
|
|
|
txn.commit();
|
2003-07-10 17:11:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
void registerValidPath(const Transaction & txn, const Path & _path)
|
2003-07-07 11:25:26 +02:00
|
|
|
{
|
2003-10-08 17:06:59 +02:00
|
|
|
Path path(canonPath(_path));
|
|
|
|
debug(format("registering path `%1%'") % path);
|
|
|
|
nixDB.setString(txn, dbValidPaths, path, "");
|
|
|
|
}
|
2003-07-07 11:25:26 +02:00
|
|
|
|
2003-07-31 18:05:35 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
bool isValidPath(const Path & path)
|
|
|
|
{
|
|
|
|
string s;
|
|
|
|
return nixDB.queryString(noTxn, dbValidPaths, path, s);
|
2003-07-07 11:25:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
void unregisterValidPath(const Path & _path)
|
2003-07-08 11:54:47 +02:00
|
|
|
{
|
2003-10-08 17:06:59 +02:00
|
|
|
Path path(canonPath(_path));
|
2003-07-31 18:05:35 +02:00
|
|
|
Transaction txn(nixDB);
|
|
|
|
|
|
|
|
debug(format("unregistering path `%1%'") % path);
|
2003-07-08 11:54:47 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
nixDB.delPair(txn, dbValidPaths, path);
|
2003-07-16 22:00:51 +02:00
|
|
|
|
2003-07-31 18:05:35 +02:00
|
|
|
txn.commit();
|
2003-07-08 11:54:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
static bool isInPrefix(const string & path, const string & _prefix)
|
2003-07-07 11:25:26 +02:00
|
|
|
{
|
|
|
|
string prefix = canonPath(_prefix + "/");
|
|
|
|
return string(path, 0, prefix.size()) == prefix;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
Path addToStore(const Path & _srcPath)
|
2003-07-07 11:25:26 +02:00
|
|
|
{
|
2003-10-08 17:06:59 +02:00
|
|
|
Path srcPath(absPath(_srcPath));
|
|
|
|
debug(format("adding `%1%' to the store") % srcPath);
|
2003-07-07 11:25:26 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
Hash h = hashPath(srcPath);
|
2003-07-10 17:11:48 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
string baseName = baseNameOf(srcPath);
|
|
|
|
Path dstPath = canonPath(nixStore + "/" + (string) h + "-" + baseName);
|
2003-07-10 17:11:48 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
if (!isValidPath(dstPath)) {
|
2003-07-10 17:11:48 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
/* The first check above is an optimisation to prevent
|
|
|
|
unnecessary lock acquisition. */
|
2003-07-22 17:15:15 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
PathSet lockPaths;
|
|
|
|
lockPaths.insert(dstPath);
|
|
|
|
PathLocks outputLock(lockPaths);
|
2003-07-22 17:15:15 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
if (!isValidPath(dstPath)) {
|
|
|
|
copyPath(srcPath, dstPath);
|
2003-08-01 11:01:51 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
Transaction txn(nixDB);
|
|
|
|
registerValidPath(txn, dstPath);
|
|
|
|
txn.commit();
|
2003-08-01 11:01:51 +02:00
|
|
|
}
|
2003-06-16 15:33:38 +02:00
|
|
|
}
|
2003-08-04 09:09:36 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
return dstPath;
|
2003-06-16 15:33:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
void deleteFromStore(const Path & _path)
|
2003-06-23 16:40:49 +02:00
|
|
|
{
|
2003-10-08 17:06:59 +02:00
|
|
|
Path path(canonPath(_path));
|
|
|
|
|
2003-07-09 18:12:40 +02:00
|
|
|
if (!isInPrefix(path, nixStore))
|
2003-10-08 17:06:59 +02:00
|
|
|
throw Error(format("path `%1%' is not in the store") % path);
|
2003-07-08 11:54:47 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
unregisterValidPath(path);
|
2003-07-08 11:54:47 +02:00
|
|
|
|
2003-06-27 16:56:12 +02:00
|
|
|
deletePath(path);
|
2003-06-23 16:40:49 +02:00
|
|
|
}
|
2003-07-17 14:27:55 +02:00
|
|
|
|
|
|
|
|
|
|
|
void verifyStore()
|
|
|
|
{
|
2003-07-31 21:49:11 +02:00
|
|
|
Transaction txn(nixDB);
|
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
Paths paths;
|
|
|
|
nixDB.enumTable(txn, dbValidPaths, paths);
|
2003-07-17 14:27:55 +02:00
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
for (Paths::iterator i = paths.begin();
|
2003-07-17 14:27:55 +02:00
|
|
|
i != paths.end(); i++)
|
|
|
|
{
|
2003-10-10 17:14:29 +02:00
|
|
|
Path path = *i;
|
2003-07-17 14:27:55 +02:00
|
|
|
if (!pathExists(path)) {
|
|
|
|
debug(format("path `%1%' disappeared") % path);
|
2003-10-10 17:14:29 +02:00
|
|
|
nixDB.delPair(txn, dbValidPaths, path);
|
|
|
|
nixDB.delPair(txn, dbSuccessorsRev, path);
|
|
|
|
nixDB.delPair(txn, dbSubstitutesRev, path);
|
2003-07-17 14:27:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
#if 0
|
2003-07-17 14:27:55 +02:00
|
|
|
Strings subs;
|
2003-07-31 21:49:11 +02:00
|
|
|
nixDB.enumTable(txn, dbSubstitutes, subs);
|
2003-07-17 14:27:55 +02:00
|
|
|
|
|
|
|
for (Strings::iterator i = subs.begin();
|
|
|
|
i != subs.end(); i++)
|
|
|
|
{
|
|
|
|
FSId srcId = parseHash(*i);
|
|
|
|
|
|
|
|
Strings subIds;
|
2003-07-31 21:49:11 +02:00
|
|
|
nixDB.queryStrings(txn, dbSubstitutes, srcId, subIds);
|
2003-07-17 14:27:55 +02:00
|
|
|
|
|
|
|
for (Strings::iterator j = subIds.begin();
|
|
|
|
j != subIds.end(); )
|
|
|
|
{
|
|
|
|
FSId subId = parseHash(*j);
|
|
|
|
|
|
|
|
Strings subPaths;
|
2003-07-31 21:49:11 +02:00
|
|
|
nixDB.queryStrings(txn, dbId2Paths, subId, subPaths);
|
2003-07-17 14:27:55 +02:00
|
|
|
if (subPaths.size() == 0) {
|
|
|
|
debug(format("erasing substitute %1% for %2%")
|
|
|
|
% (string) subId % (string) srcId);
|
|
|
|
j = subIds.erase(j);
|
|
|
|
} else j++;
|
|
|
|
}
|
|
|
|
|
2003-07-31 21:49:11 +02:00
|
|
|
nixDB.setStrings(txn, dbSubstitutes, srcId, subIds);
|
2003-07-17 14:27:55 +02:00
|
|
|
}
|
2003-10-10 17:14:29 +02:00
|
|
|
#endif
|
2003-07-17 14:27:55 +02:00
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
Paths sucs;
|
2003-07-31 21:49:11 +02:00
|
|
|
nixDB.enumTable(txn, dbSuccessors, sucs);
|
2003-07-17 14:27:55 +02:00
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
for (Paths::iterator i = sucs.begin(); i != sucs.end(); i++) {
|
|
|
|
Path srcPath = *i;
|
|
|
|
|
|
|
|
Path sucPath;
|
|
|
|
if (!nixDB.queryString(txn, dbSuccessors, srcPath, sucPath)) abort();
|
|
|
|
|
|
|
|
Paths revs;
|
|
|
|
nixDB.queryStrings(txn, dbSuccessorsRev, sucPath, revs);
|
|
|
|
|
|
|
|
if (find(revs.begin(), revs.end(), srcPath) == revs.end()) {
|
|
|
|
debug(format("reverse successor mapping from `%1%' to `%2%' missing")
|
|
|
|
% srcPath % sucPath);
|
|
|
|
revs.push_back(srcPath);
|
|
|
|
nixDB.setStrings(txn, dbSuccessorsRev, sucPath, revs);
|
2003-07-17 14:27:55 +02:00
|
|
|
}
|
|
|
|
}
|
2003-07-31 21:49:11 +02:00
|
|
|
|
|
|
|
txn.commit();
|
2003-07-17 14:27:55 +02:00
|
|
|
}
|