2007-03-30 15:24:35 +02:00
|
|
|
#include "config.h"
|
2006-11-30 18:43:04 +01:00
|
|
|
#include "local-store.hh"
|
2006-09-04 23:06:23 +02:00
|
|
|
#include "util.hh"
|
|
|
|
#include "globals.hh"
|
|
|
|
#include "db.hh"
|
|
|
|
#include "archive.hh"
|
|
|
|
#include "pathlocks.hh"
|
|
|
|
#include "aterm.hh"
|
|
|
|
#include "derivations-ast.hh"
|
2007-02-21 16:45:32 +01:00
|
|
|
#include "worker-protocol.hh"
|
2006-09-04 23:06:23 +02:00
|
|
|
|
2003-06-23 15:27:59 +02:00
|
|
|
#include <iostream>
|
2003-12-22 17:40:46 +01:00
|
|
|
#include <algorithm>
|
2003-06-23 15:27:59 +02:00
|
|
|
|
2005-01-19 17:39:47 +01:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2003-10-15 14:42:39 +02:00
|
|
|
#include <unistd.h>
|
2005-01-19 17:39:47 +01:00
|
|
|
#include <utime.h>
|
2003-06-23 15:27:59 +02:00
|
|
|
|
2006-11-30 19:35:36 +01:00
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
namespace nix {
|
2003-06-23 15:27:59 +02:00
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
|
2003-10-15 14:42:39 +02:00
|
|
|
/* Nix database. */
|
|
|
|
static Database nixDB;
|
|
|
|
|
|
|
|
|
|
|
|
/* Database tables. */
|
|
|
|
|
|
|
|
/* dbValidPaths :: Path -> ()
|
|
|
|
|
|
|
|
The existence of a key $p$ indicates that path $p$ is valid (that
|
|
|
|
is, produced by a succesful build). */
|
2004-10-25 16:38:23 +02:00
|
|
|
static TableId dbValidPaths = 0;
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-01-19 12:16:11 +01:00
|
|
|
/* dbReferences :: Path -> [Path]
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-01-19 12:16:11 +01:00
|
|
|
This table lists the outgoing file system references for each
|
|
|
|
output path that has been built by a Nix derivation. These are
|
|
|
|
found by scanning the path for the hash components of input
|
|
|
|
paths. */
|
|
|
|
static TableId dbReferences = 0;
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
/* dbReferrers :: Path -> Path
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
This table is just the reverse mapping of dbReferences. This table
|
|
|
|
can have duplicate keys, each corresponding value denoting a single
|
|
|
|
referrer. */
|
|
|
|
static TableId dbReferrers = 0;
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-02-07 14:40:40 +01:00
|
|
|
/* dbDerivers :: Path -> [Path]
|
|
|
|
|
|
|
|
This table lists the derivation used to build a path. There can
|
|
|
|
only be multiple such paths for fixed-output derivations (i.e.,
|
|
|
|
derivations specifying an expected hash). */
|
|
|
|
static TableId dbDerivers = 0;
|
|
|
|
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
static void upgradeStore07();
|
|
|
|
static void upgradeStore09();
|
2007-08-13 13:37:39 +02:00
|
|
|
static void upgradeStore11();
|
2005-02-09 10:50:29 +01:00
|
|
|
|
|
|
|
|
2006-03-10 23:27:26 +01:00
|
|
|
void checkStoreNotSymlink()
|
|
|
|
{
|
|
|
|
if (getEnv("NIX_IGNORE_SYMLINK_STORE") == "1") return;
|
|
|
|
Path path = nixStore;
|
|
|
|
struct stat st;
|
|
|
|
while (path != "/") {
|
|
|
|
if (lstat(path.c_str(), &st))
|
|
|
|
throw SysError(format("getting status of `%1%'") % path);
|
|
|
|
if (S_ISLNK(st.st_mode))
|
|
|
|
throw Error(format(
|
|
|
|
"the path `%1%' is a symlink; "
|
|
|
|
"this is not allowed for the Nix store and its parent directories")
|
|
|
|
% path);
|
|
|
|
path = dirOf(path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
LocalStore::LocalStore(bool reserveSpace)
|
2003-10-15 14:42:39 +02:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
substitutablePathsLoaded = false;
|
|
|
|
|
2004-10-25 16:38:23 +02:00
|
|
|
if (readOnlyMode) return;
|
2005-02-09 10:50:29 +01:00
|
|
|
|
2006-03-10 23:27:26 +01:00
|
|
|
checkStoreNotSymlink();
|
|
|
|
|
2006-02-16 14:19:15 +01:00
|
|
|
try {
|
|
|
|
Path reservedPath = nixDBPath + "/reserved";
|
2006-02-16 14:58:10 +01:00
|
|
|
string s = querySetting("gc-reserved-space", "");
|
|
|
|
int reservedSize;
|
|
|
|
if (!string2Int(s, reservedSize)) reservedSize = 1024 * 1024;
|
2006-02-16 14:19:15 +01:00
|
|
|
if (reserveSpace) {
|
|
|
|
struct stat st;
|
|
|
|
if (stat(reservedPath.c_str(), &st) == -1 ||
|
|
|
|
st.st_size != reservedSize)
|
2006-02-16 14:58:10 +01:00
|
|
|
writeFile(reservedPath, string(reservedSize, 'X'));
|
2006-02-16 14:19:15 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
deletePath(reservedPath);
|
|
|
|
} catch (SysError & e) { /* don't care about errors */
|
|
|
|
}
|
|
|
|
|
2004-10-25 16:38:23 +02:00
|
|
|
try {
|
|
|
|
nixDB.open(nixDBPath);
|
|
|
|
} catch (DbNoPermission & e) {
|
|
|
|
printMsg(lvlTalkative, "cannot access Nix database; continuing anyway");
|
|
|
|
readOnlyMode = true;
|
|
|
|
return;
|
|
|
|
}
|
2003-10-15 14:42:39 +02:00
|
|
|
dbValidPaths = nixDB.openTable("validpaths");
|
2005-01-19 12:16:11 +01:00
|
|
|
dbReferences = nixDB.openTable("references");
|
2005-12-12 19:24:42 +01:00
|
|
|
dbReferrers = nixDB.openTable("referrers", true); /* must be sorted */
|
2005-02-07 14:40:40 +01:00
|
|
|
dbDerivers = nixDB.openTable("derivers");
|
2005-02-09 10:50:29 +01:00
|
|
|
|
|
|
|
int curSchema = 0;
|
|
|
|
Path schemaFN = nixDBPath + "/schema";
|
|
|
|
if (pathExists(schemaFN)) {
|
|
|
|
string s = readFile(schemaFN);
|
|
|
|
if (!string2Int(s, curSchema))
|
|
|
|
throw Error(format("`%1%' is corrupt") % schemaFN);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (curSchema > nixSchemaVersion)
|
|
|
|
throw Error(format("current Nix store schema is version %1%, but I only support %2%")
|
|
|
|
% curSchema % nixSchemaVersion);
|
|
|
|
|
|
|
|
if (curSchema < nixSchemaVersion) {
|
2005-12-12 19:24:42 +01:00
|
|
|
if (curSchema <= 1)
|
|
|
|
upgradeStore07();
|
|
|
|
if (curSchema == 2)
|
|
|
|
upgradeStore09();
|
2007-08-13 13:37:39 +02:00
|
|
|
if (curSchema == 3)
|
|
|
|
upgradeStore11();
|
2005-02-09 10:50:29 +01:00
|
|
|
writeFile(schemaFN, (format("%1%") % nixSchemaVersion).str());
|
|
|
|
}
|
2003-10-15 14:42:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
LocalStore::~LocalStore()
|
2006-03-01 17:36:35 +01:00
|
|
|
{
|
|
|
|
/* If the database isn't open, this is a NOP. */
|
2007-05-01 17:16:17 +02:00
|
|
|
try {
|
|
|
|
nixDB.close();
|
|
|
|
} catch (...) {
|
|
|
|
ignoreException();
|
|
|
|
}
|
2006-03-01 17:36:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-15 14:42:39 +02:00
|
|
|
void createStoreTransaction(Transaction & txn)
|
|
|
|
{
|
|
|
|
Transaction txn2(nixDB);
|
|
|
|
txn2.moveTo(txn);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-12-13 00:05:01 +01:00
|
|
|
void copyPath(const Path & src, const Path & dst, PathFilter & filter)
|
2003-06-16 15:33:38 +02:00
|
|
|
{
|
2003-07-31 18:05:35 +02:00
|
|
|
debug(format("copying `%1%' to `%2%'") % src % dst);
|
|
|
|
|
2005-03-03 14:58:02 +01:00
|
|
|
/* Dump an archive of the path `src' into a string buffer, then
|
|
|
|
restore the archive to `dst'. This is not a very good method
|
|
|
|
for very large paths, but `copyPath' is mainly used for small
|
|
|
|
files. */
|
2003-06-23 15:27:59 +02:00
|
|
|
|
2006-12-13 00:05:01 +01:00
|
|
|
StringSink sink;
|
|
|
|
dumpPath(src, sink, filter);
|
2003-06-23 15:27:59 +02:00
|
|
|
|
2006-12-13 00:05:01 +01:00
|
|
|
StringSource source(sink.s);
|
2005-03-03 14:58:02 +01:00
|
|
|
restorePath(dst, source);
|
2003-06-16 15:33:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-10 00:14:27 +02:00
|
|
|
static void _canonicalisePathMetaData(const Path & path, bool recurse)
|
2005-01-19 17:39:47 +01:00
|
|
|
{
|
|
|
|
checkInterrupt();
|
|
|
|
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(path.c_str(), &st))
|
|
|
|
throw SysError(format("getting attributes of path `%1%'") % path);
|
|
|
|
|
2006-12-09 21:02:27 +01:00
|
|
|
/* Change ownership to the current uid. If its a symlink, use
|
|
|
|
lchown if available, otherwise don't bother. Wrong ownership
|
|
|
|
of a symlink doesn't matter, since the owning user can't change
|
|
|
|
the symlink and can't delete it because the directory is not
|
|
|
|
writable. The only exception is top-level paths in the Nix
|
|
|
|
store (since that directory is group-writable for the Nix build
|
|
|
|
users group); we check for this case below. */
|
|
|
|
if (st.st_uid != geteuid()) {
|
|
|
|
#if HAVE_LCHOWN
|
2007-02-06 21:03:53 +01:00
|
|
|
if (lchown(path.c_str(), geteuid(), (gid_t) -1) == -1)
|
2006-12-09 21:02:27 +01:00
|
|
|
#else
|
|
|
|
if (!S_ISLNK(st.st_mode) &&
|
2007-02-06 21:03:53 +01:00
|
|
|
chown(path.c_str(), geteuid(), (gid_t) -1) == -1)
|
2006-12-09 21:02:27 +01:00
|
|
|
#endif
|
|
|
|
throw SysError(format("changing owner of `%1%' to %2%")
|
|
|
|
% path % geteuid());
|
|
|
|
}
|
|
|
|
|
2005-01-19 17:39:47 +01:00
|
|
|
if (!S_ISLNK(st.st_mode)) {
|
|
|
|
|
|
|
|
/* Mask out all type related bits. */
|
|
|
|
mode_t mode = st.st_mode & ~S_IFMT;
|
|
|
|
|
|
|
|
if (mode != 0444 && mode != 0555) {
|
|
|
|
mode = (st.st_mode & S_IFMT)
|
|
|
|
| 0444
|
|
|
|
| (st.st_mode & S_IXUSR ? 0111 : 0);
|
|
|
|
if (chmod(path.c_str(), mode) == -1)
|
|
|
|
throw SysError(format("changing mode of `%1%' to %2$o") % path % mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (st.st_mtime != 0) {
|
|
|
|
struct utimbuf utimbuf;
|
|
|
|
utimbuf.actime = st.st_atime;
|
|
|
|
utimbuf.modtime = 0;
|
|
|
|
if (utime(path.c_str(), &utimbuf) == -1)
|
|
|
|
throw SysError(format("changing modification time of `%1%'") % path);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2007-10-10 00:14:27 +02:00
|
|
|
if (recurse && S_ISDIR(st.st_mode)) {
|
2005-01-19 17:39:47 +01:00
|
|
|
Strings names = readDirectory(path);
|
|
|
|
for (Strings::iterator i = names.begin(); i != names.end(); ++i)
|
2007-10-10 00:14:27 +02:00
|
|
|
_canonicalisePathMetaData(path + "/" + *i, true);
|
2006-12-09 21:02:27 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void canonicalisePathMetaData(const Path & path)
|
|
|
|
{
|
2007-10-10 00:14:27 +02:00
|
|
|
_canonicalisePathMetaData(path, true);
|
2006-12-09 21:02:27 +01:00
|
|
|
|
|
|
|
/* On platforms that don't have lchown(), the top-level path can't
|
|
|
|
be a symlink, since we can't change its ownership. */
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(path.c_str(), &st))
|
|
|
|
throw SysError(format("getting attributes of path `%1%'") % path);
|
|
|
|
|
|
|
|
if (st.st_uid != geteuid()) {
|
|
|
|
assert(S_ISLNK(st.st_mode));
|
|
|
|
throw Error(format("wrong ownership of top-level store path `%1%'") % path);
|
2005-01-19 17:39:47 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-23 12:25:20 +01:00
|
|
|
bool isValidPathTxn(const Transaction & txn, const Path & path)
|
2003-12-05 12:05:19 +01:00
|
|
|
{
|
|
|
|
string s;
|
|
|
|
return nixDB.queryString(txn, dbValidPaths, path, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
bool LocalStore::isValidPath(const Path & path)
|
2003-12-05 12:05:19 +01:00
|
|
|
{
|
2005-01-25 22:28:25 +01:00
|
|
|
return isValidPathTxn(noTxn, path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
static string addPrefix(const string & prefix, const string & s)
|
|
|
|
{
|
2005-12-25 03:02:29 +01:00
|
|
|
return prefix + string(1, (char) 0) + s;
|
2005-12-12 19:24:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static string stripPrefix(const string & prefix, const string & s)
|
|
|
|
{
|
|
|
|
if (s.size() <= prefix.size() ||
|
2005-12-25 00:32:59 +01:00
|
|
|
string(s, 0, prefix.size()) != prefix ||
|
2005-12-12 19:24:42 +01:00
|
|
|
s[prefix.size()] != 0)
|
|
|
|
throw Error(format("string `%1%' is missing prefix `%2%'")
|
|
|
|
% s % prefix);
|
|
|
|
return string(s, prefix.size() + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-13 22:04:48 +01:00
|
|
|
static PathSet getReferrers(const Transaction & txn, const Path & storePath)
|
2005-01-27 17:18:39 +01:00
|
|
|
{
|
2005-12-12 19:24:42 +01:00
|
|
|
PathSet referrers;
|
|
|
|
Strings keys;
|
2005-12-25 03:02:29 +01:00
|
|
|
nixDB.enumTable(txn, dbReferrers, keys, storePath + string(1, (char) 0));
|
2005-12-12 19:24:42 +01:00
|
|
|
for (Strings::iterator i = keys.begin(); i != keys.end(); ++i)
|
|
|
|
referrers.insert(stripPrefix(storePath, *i));
|
|
|
|
return referrers;
|
2005-01-27 17:18:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-19 12:16:11 +01:00
|
|
|
void setReferences(const Transaction & txn, const Path & storePath,
|
|
|
|
const PathSet & references)
|
2003-10-10 16:46:28 +02:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
/* For invalid paths, we can only clear the references. */
|
|
|
|
if (references.size() > 0 && !isValidPathTxn(txn, storePath))
|
2005-01-25 22:28:25 +01:00
|
|
|
throw Error(
|
2007-08-12 02:29:28 +02:00
|
|
|
format("cannot set references for invalid path `%1%'") % storePath);
|
2005-01-27 17:18:39 +01:00
|
|
|
|
|
|
|
Paths oldReferences;
|
2005-01-27 18:48:14 +01:00
|
|
|
nixDB.queryStrings(txn, dbReferences, storePath, oldReferences);
|
2005-03-03 14:10:44 +01:00
|
|
|
|
|
|
|
PathSet oldReferences2(oldReferences.begin(), oldReferences.end());
|
|
|
|
if (oldReferences2 == references) return;
|
2005-01-25 22:28:25 +01:00
|
|
|
|
2005-01-19 12:16:11 +01:00
|
|
|
nixDB.setStrings(txn, dbReferences, storePath,
|
|
|
|
Paths(references.begin(), references.end()));
|
2003-12-05 12:05:19 +01:00
|
|
|
|
2005-12-13 22:04:48 +01:00
|
|
|
/* Update the referrers mappings of all new referenced paths. */
|
2005-01-19 12:16:11 +01:00
|
|
|
for (PathSet::const_iterator i = references.begin();
|
|
|
|
i != references.end(); ++i)
|
2005-12-12 19:24:42 +01:00
|
|
|
if (oldReferences2.find(*i) == oldReferences2.end())
|
|
|
|
nixDB.setString(txn, dbReferrers, addPrefix(*i, storePath), "");
|
2005-01-27 17:18:39 +01:00
|
|
|
|
2005-12-13 22:04:48 +01:00
|
|
|
/* Remove referrer mappings from paths that are no longer
|
2005-01-27 17:18:39 +01:00
|
|
|
references. */
|
|
|
|
for (Paths::iterator i = oldReferences.begin();
|
|
|
|
i != oldReferences.end(); ++i)
|
2005-12-12 19:24:42 +01:00
|
|
|
if (references.find(*i) == references.end())
|
|
|
|
nixDB.delPair(txn, dbReferrers, addPrefix(*i, storePath));
|
2003-10-15 14:42:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-08 14:23:55 +01:00
|
|
|
void queryReferences(const Transaction & txn,
|
|
|
|
const Path & storePath, PathSet & references)
|
2003-10-10 17:25:21 +02:00
|
|
|
{
|
2005-01-19 12:16:11 +01:00
|
|
|
Paths references2;
|
2007-08-12 02:29:28 +02:00
|
|
|
if (!isValidPathTxn(txn, storePath))
|
2005-01-25 22:28:25 +01:00
|
|
|
throw Error(format("path `%1%' is not valid") % storePath);
|
2005-02-08 14:23:55 +01:00
|
|
|
nixDB.queryStrings(txn, dbReferences, storePath, references2);
|
2005-01-19 12:16:11 +01:00
|
|
|
references.insert(references2.begin(), references2.end());
|
2003-10-10 17:25:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
void LocalStore::queryReferences(const Path & storePath,
|
|
|
|
PathSet & references)
|
|
|
|
{
|
|
|
|
nix::queryReferences(noTxn, storePath, references);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-13 22:04:48 +01:00
|
|
|
void queryReferrers(const Transaction & txn,
|
|
|
|
const Path & storePath, PathSet & referrers)
|
2005-01-19 17:59:56 +01:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
if (!isValidPathTxn(txn, storePath))
|
2005-01-25 22:28:25 +01:00
|
|
|
throw Error(format("path `%1%' is not valid") % storePath);
|
2005-12-13 22:04:48 +01:00
|
|
|
PathSet referrers2 = getReferrers(txn, storePath);
|
|
|
|
referrers.insert(referrers2.begin(), referrers2.end());
|
2005-01-19 17:59:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
void LocalStore::queryReferrers(const Path & storePath,
|
|
|
|
PathSet & referrers)
|
|
|
|
{
|
|
|
|
nix::queryReferrers(noTxn, storePath, referrers);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-07 14:40:40 +01:00
|
|
|
void setDeriver(const Transaction & txn, const Path & storePath,
|
|
|
|
const Path & deriver)
|
|
|
|
{
|
|
|
|
assertStorePath(storePath);
|
|
|
|
if (deriver == "") return;
|
|
|
|
assertStorePath(deriver);
|
2007-08-12 02:29:28 +02:00
|
|
|
if (!isValidPathTxn(txn, storePath))
|
2005-02-07 14:40:40 +01:00
|
|
|
throw Error(format("path `%1%' is not valid") % storePath);
|
|
|
|
nixDB.setString(txn, dbDerivers, storePath, deriver);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-12 18:53:44 +02:00
|
|
|
static Path queryDeriver(const Transaction & txn, const Path & storePath)
|
2005-02-07 14:40:40 +01:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
if (!isValidPathTxn(txn, storePath))
|
2005-02-07 14:40:40 +01:00
|
|
|
throw Error(format("path `%1%' is not valid") % storePath);
|
|
|
|
Path deriver;
|
|
|
|
if (nixDB.queryString(txn, dbDerivers, storePath, deriver))
|
|
|
|
return deriver;
|
|
|
|
else
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-06-12 18:53:44 +02:00
|
|
|
Path LocalStore::queryDeriver(const Path & path)
|
|
|
|
{
|
|
|
|
return nix::queryDeriver(noTxn, path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-12 02:29:28 +02:00
|
|
|
PathSet LocalStore::querySubstitutablePaths()
|
2003-07-10 17:11:48 +02:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
if (!substitutablePathsLoaded) {
|
|
|
|
for (Paths::iterator i = substituters.begin(); i != substituters.end(); ++i) {
|
|
|
|
debug(format("running `%1%' to find out substitutable paths") % *i);
|
|
|
|
Strings args;
|
|
|
|
args.push_back("--query-paths");
|
|
|
|
Strings ss = tokenizeString(runProgram(*i, false, args), "\n");
|
|
|
|
for (Strings::iterator j = ss.begin(); j != ss.end(); ++j) {
|
|
|
|
if (!isStorePath(*j))
|
|
|
|
throw Error(format("`%1%' returned a bad substitutable path `%2%'")
|
|
|
|
% *i % *j);
|
|
|
|
substitutablePaths.insert(*j);
|
|
|
|
}
|
2004-06-20 21:17:54 +02:00
|
|
|
}
|
2007-08-12 02:29:28 +02:00
|
|
|
substitutablePathsLoaded = true;
|
2004-06-20 21:17:54 +02:00
|
|
|
}
|
2003-12-05 12:05:19 +01:00
|
|
|
|
2007-08-12 02:29:28 +02:00
|
|
|
return substitutablePaths;
|
2004-06-20 21:17:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-12 02:29:28 +02:00
|
|
|
bool LocalStore::hasSubstitutes(const Path & path)
|
2004-06-20 21:17:54 +02:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
if (!substitutablePathsLoaded)
|
|
|
|
querySubstitutablePaths();
|
|
|
|
return substitutablePaths.find(path) != substitutablePaths.end();
|
2004-12-20 14:43:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-09 10:50:29 +01:00
|
|
|
static void setHash(const Transaction & txn, const Path & storePath,
|
|
|
|
const Hash & hash)
|
|
|
|
{
|
|
|
|
assert(hash.type == htSHA256);
|
|
|
|
nixDB.setString(txn, dbValidPaths, storePath, "sha256:" + printHash(hash));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static Hash queryHash(const Transaction & txn, const Path & storePath)
|
|
|
|
{
|
|
|
|
string s;
|
|
|
|
nixDB.queryString(txn, dbValidPaths, storePath, s);
|
2006-05-11 04:19:43 +02:00
|
|
|
string::size_type colon = s.find(':');
|
2005-02-09 10:50:29 +01:00
|
|
|
if (colon == string::npos)
|
|
|
|
throw Error(format("corrupt hash `%1%' in valid-path entry for `%2%'")
|
|
|
|
% s % storePath);
|
|
|
|
HashType ht = parseHashType(string(s, 0, colon));
|
|
|
|
if (ht == htUnknown)
|
|
|
|
throw Error(format("unknown hash type `%1%' in valid-path entry for `%2%'")
|
2005-02-14 10:53:11 +01:00
|
|
|
% string(s, 0, colon) % storePath);
|
2005-02-09 10:50:29 +01:00
|
|
|
return parseHash(ht, string(s, colon + 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
Hash LocalStore::queryPathHash(const Path & path)
|
2005-03-02 16:57:06 +01:00
|
|
|
{
|
|
|
|
if (!isValidPath(path))
|
|
|
|
throw Error(format("path `%1%' is not valid") % path);
|
|
|
|
return queryHash(noTxn, path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-19 17:39:47 +01:00
|
|
|
void registerValidPath(const Transaction & txn,
|
2005-03-23 14:07:28 +01:00
|
|
|
const Path & path, const Hash & hash, const PathSet & references,
|
2005-02-07 14:40:40 +01:00
|
|
|
const Path & deriver)
|
2003-07-07 11:25:26 +02:00
|
|
|
{
|
2005-03-23 14:07:28 +01:00
|
|
|
ValidPathInfo info;
|
|
|
|
info.path = path;
|
|
|
|
info.hash = hash;
|
|
|
|
info.references = references;
|
|
|
|
info.deriver = deriver;
|
|
|
|
ValidPathInfos infos;
|
|
|
|
infos.push_back(info);
|
|
|
|
registerValidPaths(txn, infos);
|
|
|
|
}
|
2005-01-19 17:39:47 +01:00
|
|
|
|
|
|
|
|
2005-03-23 14:07:28 +01:00
|
|
|
void registerValidPaths(const Transaction & txn,
|
|
|
|
const ValidPathInfos & infos)
|
|
|
|
{
|
|
|
|
PathSet newPaths;
|
|
|
|
for (ValidPathInfos::const_iterator i = infos.begin();
|
|
|
|
i != infos.end(); ++i)
|
|
|
|
newPaths.insert(i->path);
|
|
|
|
|
|
|
|
for (ValidPathInfos::const_iterator i = infos.begin();
|
|
|
|
i != infos.end(); ++i)
|
|
|
|
{
|
|
|
|
assertStorePath(i->path);
|
|
|
|
|
|
|
|
debug(format("registering path `%1%'") % i->path);
|
|
|
|
setHash(txn, i->path, i->hash);
|
2005-02-07 14:40:40 +01:00
|
|
|
|
2005-03-23 14:07:28 +01:00
|
|
|
setReferences(txn, i->path, i->references);
|
|
|
|
|
|
|
|
/* Check that all referenced paths are also valid (or about to
|
|
|
|
become valid). */
|
|
|
|
for (PathSet::iterator j = i->references.begin();
|
|
|
|
j != i->references.end(); ++j)
|
|
|
|
if (!isValidPathTxn(txn, *j) && newPaths.find(*j) == newPaths.end())
|
|
|
|
throw Error(format("cannot register path `%1%' as valid, since its reference `%2%' is invalid")
|
|
|
|
% i->path % *j);
|
|
|
|
|
|
|
|
setDeriver(txn, i->path, i->deriver);
|
|
|
|
}
|
2003-10-08 17:06:59 +02:00
|
|
|
}
|
2003-07-07 11:25:26 +02:00
|
|
|
|
2003-07-31 18:05:35 +02:00
|
|
|
|
2005-01-31 15:00:43 +01:00
|
|
|
/* Invalidate a path. The caller is responsible for checking that
|
2005-12-13 22:04:48 +01:00
|
|
|
there are no referrers. */
|
2005-03-03 14:10:44 +01:00
|
|
|
static void invalidatePath(Transaction & txn, const Path & path)
|
2003-07-08 11:54:47 +02:00
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
debug(format("invalidating path `%1%'") % path);
|
2003-07-08 11:54:47 +02:00
|
|
|
|
2005-01-27 16:21:29 +01:00
|
|
|
/* Clear the `references' entry for this path, as well as the
|
2007-08-12 02:29:28 +02:00
|
|
|
inverse `referrers' entries, and the `derivers' entry. */
|
|
|
|
setReferences(txn, path, PathSet());
|
|
|
|
nixDB.delPair(txn, dbDerivers, path);
|
2005-01-27 17:18:39 +01:00
|
|
|
nixDB.delPair(txn, dbValidPaths, path);
|
2003-07-08 11:54:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-12-01 21:51:18 +01:00
|
|
|
Path LocalStore::addToStore(const Path & _srcPath, bool fixed,
|
2006-12-13 00:05:01 +01:00
|
|
|
bool recursive, string hashAlgo, PathFilter & filter)
|
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
|
|
|
|
2006-12-01 19:00:01 +01:00
|
|
|
std::pair<Path, Hash> pr =
|
2006-12-13 00:05:01 +01:00
|
|
|
computeStorePathForPath(srcPath, fixed, recursive, hashAlgo, filter);
|
2006-12-01 19:00:01 +01:00
|
|
|
Path & dstPath(pr.first);
|
|
|
|
Hash & h(pr.second);
|
2003-07-10 17:11:48 +02:00
|
|
|
|
2006-12-01 21:51:18 +01:00
|
|
|
addTempRoot(dstPath);
|
2005-01-31 11:27:25 +01:00
|
|
|
|
2006-12-01 21:51:18 +01: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
|
|
|
|
2006-06-01 20:13:33 +02:00
|
|
|
PathLocks outputLock(singleton<PathSet, Path>(dstPath));
|
2003-07-22 17:15:15 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
if (!isValidPath(dstPath)) {
|
2004-06-21 09:46:02 +02:00
|
|
|
|
2006-12-09 01:26:24 +01:00
|
|
|
if (pathExists(dstPath)) deletePathWrapped(dstPath);
|
2004-10-25 16:38:23 +02:00
|
|
|
|
2006-12-13 00:05:01 +01:00
|
|
|
copyPath(srcPath, dstPath, filter);
|
2003-08-01 11:01:51 +02:00
|
|
|
|
2006-12-13 00:05:01 +01:00
|
|
|
Hash h2 = hashPath(htSHA256, dstPath, filter);
|
2005-01-14 14:51:38 +01:00
|
|
|
if (h != h2)
|
|
|
|
throw Error(format("contents of `%1%' changed while copying it to `%2%' (%3% -> %4%)")
|
2005-01-14 17:04:03 +01:00
|
|
|
% srcPath % dstPath % printHash(h) % printHash(h2));
|
2005-01-14 14:51:38 +01:00
|
|
|
|
2005-01-19 17:39:47 +01:00
|
|
|
canonicalisePathMetaData(dstPath);
|
2004-09-09 23:19:20 +02:00
|
|
|
|
2003-10-08 17:06:59 +02:00
|
|
|
Transaction txn(nixDB);
|
2005-02-07 14:40:40 +01:00
|
|
|
registerValidPath(txn, dstPath, h, PathSet(), "");
|
2003-10-08 17:06:59 +02:00
|
|
|
txn.commit();
|
2003-08-01 11:01:51 +02:00
|
|
|
}
|
2003-11-22 19:45:56 +01:00
|
|
|
|
|
|
|
outputLock.setDeletion(true);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
Path LocalStore::addTextToStore(const string & suffix, const string & s,
|
2005-01-25 22:28:25 +01:00
|
|
|
const PathSet & references)
|
2003-10-15 14:42:39 +02:00
|
|
|
{
|
2007-01-29 16:51:37 +01:00
|
|
|
Path dstPath = computeStorePathForText(suffix, s, references);
|
2004-02-14 22:44:18 +01:00
|
|
|
|
2006-12-01 21:51:18 +01:00
|
|
|
addTempRoot(dstPath);
|
2005-01-31 11:27:25 +01:00
|
|
|
|
2006-12-01 21:51:18 +01:00
|
|
|
if (!isValidPath(dstPath)) {
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2006-06-01 20:13:33 +02:00
|
|
|
PathLocks outputLock(singleton<PathSet, Path>(dstPath));
|
2003-10-23 12:51:55 +02:00
|
|
|
|
|
|
|
if (!isValidPath(dstPath)) {
|
2004-06-21 09:46:02 +02:00
|
|
|
|
2006-12-09 01:26:24 +01:00
|
|
|
if (pathExists(dstPath)) deletePathWrapped(dstPath);
|
2004-06-21 09:46:02 +02:00
|
|
|
|
2003-11-22 16:58:34 +01:00
|
|
|
writeStringToFile(dstPath, s);
|
2003-10-15 14:42:39 +02:00
|
|
|
|
2005-01-19 17:39:47 +01:00
|
|
|
canonicalisePathMetaData(dstPath);
|
2004-09-09 23:19:20 +02:00
|
|
|
|
2003-10-23 12:51:55 +02:00
|
|
|
Transaction txn(nixDB);
|
2005-01-25 22:28:25 +01:00
|
|
|
registerValidPath(txn, dstPath,
|
2005-02-07 14:40:40 +01:00
|
|
|
hashPath(htSHA256, dstPath), references, "");
|
2003-10-23 12:51:55 +02:00
|
|
|
txn.commit();
|
|
|
|
}
|
2003-11-22 19:45:56 +01:00
|
|
|
|
|
|
|
outputLock.setDeletion(true);
|
2003-10-15 14:42:39 +02:00
|
|
|
}
|
2005-01-14 14:51:38 +01:00
|
|
|
|
|
|
|
return dstPath;
|
2003-10-15 14:42:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-21 15:31:42 +01:00
|
|
|
struct HashAndWriteSink : Sink
|
|
|
|
{
|
|
|
|
Sink & writeSink;
|
|
|
|
HashSink hashSink;
|
|
|
|
bool hashing;
|
|
|
|
HashAndWriteSink(Sink & writeSink) : writeSink(writeSink), hashSink(htSHA256)
|
|
|
|
{
|
|
|
|
hashing = true;
|
|
|
|
}
|
|
|
|
virtual void operator ()
|
|
|
|
(const unsigned char * data, unsigned int len)
|
|
|
|
{
|
|
|
|
writeSink(data, len);
|
|
|
|
if (hashing) hashSink(data, len);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#define EXPORT_MAGIC 0x4558494e
|
|
|
|
|
|
|
|
|
2007-02-21 18:51:10 +01:00
|
|
|
static void checkSecrecy(const Path & path)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
if (stat(path.c_str(), &st))
|
|
|
|
throw SysError(format("getting status of `%1%'") % path);
|
|
|
|
if ((st.st_mode & (S_IRWXG | S_IRWXO)) != 0)
|
|
|
|
throw Error(format("file `%1%' should be secret (inaccessible to everybody else)!") % path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-21 00:17:20 +01:00
|
|
|
void LocalStore::exportPath(const Path & path, bool sign,
|
|
|
|
Sink & sink)
|
|
|
|
{
|
|
|
|
assertStorePath(path);
|
2007-02-21 15:31:42 +01:00
|
|
|
|
2007-02-21 17:23:25 +01:00
|
|
|
/* Wrap all of this in a transaction to make sure that we export
|
|
|
|
consistent metadata. */
|
|
|
|
Transaction txn(nixDB);
|
|
|
|
addTempRoot(path);
|
2007-10-10 00:14:27 +02:00
|
|
|
if (!isValidPathTxn(txn, path))
|
2007-02-21 17:23:25 +01:00
|
|
|
throw Error(format("path `%1%' is not valid") % path);
|
|
|
|
|
2007-02-21 15:31:42 +01:00
|
|
|
HashAndWriteSink hashAndWriteSink(sink);
|
2007-02-21 00:17:20 +01:00
|
|
|
|
2007-02-21 15:31:42 +01:00
|
|
|
dumpPath(path, hashAndWriteSink);
|
2007-02-21 00:17:20 +01:00
|
|
|
|
2007-02-21 15:31:42 +01:00
|
|
|
writeInt(EXPORT_MAGIC, hashAndWriteSink);
|
|
|
|
|
|
|
|
writeString(path, hashAndWriteSink);
|
2007-02-21 00:17:20 +01:00
|
|
|
|
|
|
|
PathSet references;
|
2007-02-21 17:23:25 +01:00
|
|
|
nix::queryReferences(txn, path, references);
|
2007-02-21 15:31:42 +01:00
|
|
|
writeStringSet(references, hashAndWriteSink);
|
2007-02-21 00:17:20 +01:00
|
|
|
|
2007-06-12 18:53:44 +02:00
|
|
|
Path deriver = nix::queryDeriver(txn, path);
|
2007-02-21 15:31:42 +01:00
|
|
|
writeString(deriver, hashAndWriteSink);
|
|
|
|
|
|
|
|
if (sign) {
|
|
|
|
Hash hash = hashAndWriteSink.hashSink.finish();
|
|
|
|
hashAndWriteSink.hashing = false;
|
|
|
|
|
|
|
|
writeInt(1, hashAndWriteSink);
|
|
|
|
|
|
|
|
Path tmpDir = createTempDir();
|
|
|
|
AutoDelete delTmp(tmpDir);
|
|
|
|
Path hashFile = tmpDir + "/hash";
|
|
|
|
writeStringToFile(hashFile, printHash(hash));
|
|
|
|
|
2007-02-21 18:51:10 +01:00
|
|
|
Path secretKey = nixConfDir + "/signing-key.sec";
|
|
|
|
checkSecrecy(secretKey);
|
|
|
|
|
2007-02-21 15:31:42 +01:00
|
|
|
Strings args;
|
|
|
|
args.push_back("rsautl");
|
|
|
|
args.push_back("-sign");
|
|
|
|
args.push_back("-inkey");
|
2007-02-21 18:51:10 +01:00
|
|
|
args.push_back(secretKey);
|
2007-02-21 15:31:42 +01:00
|
|
|
args.push_back("-in");
|
|
|
|
args.push_back(hashFile);
|
2007-03-01 14:30:46 +01:00
|
|
|
string signature = runProgram(OPENSSL_PATH, true, args);
|
2007-02-21 15:31:42 +01:00
|
|
|
|
|
|
|
writeString(signature, hashAndWriteSink);
|
|
|
|
|
|
|
|
} else
|
|
|
|
writeInt(0, hashAndWriteSink);
|
2007-02-21 17:23:25 +01:00
|
|
|
|
|
|
|
txn.commit();
|
2007-02-21 00:17:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-21 16:45:32 +01:00
|
|
|
struct HashAndReadSource : Source
|
|
|
|
{
|
|
|
|
Source & readSource;
|
|
|
|
HashSink hashSink;
|
|
|
|
bool hashing;
|
|
|
|
HashAndReadSource(Source & readSource) : readSource(readSource), hashSink(htSHA256)
|
|
|
|
{
|
|
|
|
hashing = true;
|
|
|
|
}
|
|
|
|
virtual void operator ()
|
|
|
|
(unsigned char * data, unsigned int len)
|
|
|
|
{
|
|
|
|
readSource(data, len);
|
|
|
|
if (hashing) hashSink(data, len);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
Path LocalStore::importPath(bool requireSignature, Source & source)
|
|
|
|
{
|
|
|
|
HashAndReadSource hashAndReadSource(source);
|
|
|
|
|
|
|
|
/* We don't yet know what store path this archive contains (the
|
|
|
|
store path follows the archive data proper), and besides, we
|
|
|
|
don't know yet whether the signature is valid. */
|
|
|
|
Path tmpDir = createTempDir(nixStore);
|
|
|
|
AutoDelete delTmp(tmpDir);
|
|
|
|
Path unpacked = tmpDir + "/unpacked";
|
|
|
|
|
|
|
|
restorePath(unpacked, hashAndReadSource);
|
|
|
|
|
|
|
|
unsigned int magic = readInt(hashAndReadSource);
|
|
|
|
if (magic != EXPORT_MAGIC)
|
|
|
|
throw Error("Nix archive cannot be imported; wrong format");
|
|
|
|
|
|
|
|
Path dstPath = readStorePath(hashAndReadSource);
|
|
|
|
|
|
|
|
PathSet references = readStorePaths(hashAndReadSource);
|
|
|
|
|
2007-02-28 00:18:57 +01:00
|
|
|
Path deriver = readString(hashAndReadSource);
|
|
|
|
if (deriver != "") assertStorePath(deriver);
|
2007-02-21 16:45:32 +01:00
|
|
|
|
|
|
|
Hash hash = hashAndReadSource.hashSink.finish();
|
|
|
|
hashAndReadSource.hashing = false;
|
|
|
|
|
|
|
|
bool haveSignature = readInt(hashAndReadSource) == 1;
|
|
|
|
|
|
|
|
if (requireSignature && !haveSignature)
|
|
|
|
throw Error("imported archive lacks a signature");
|
|
|
|
|
|
|
|
if (haveSignature) {
|
|
|
|
string signature = readString(hashAndReadSource);
|
|
|
|
|
2007-03-01 13:30:24 +01:00
|
|
|
if (requireSignature) {
|
|
|
|
Path sigFile = tmpDir + "/sig";
|
|
|
|
writeStringToFile(sigFile, signature);
|
|
|
|
|
|
|
|
Strings args;
|
|
|
|
args.push_back("rsautl");
|
|
|
|
args.push_back("-verify");
|
|
|
|
args.push_back("-inkey");
|
|
|
|
args.push_back(nixConfDir + "/signing-key.pub");
|
|
|
|
args.push_back("-pubin");
|
|
|
|
args.push_back("-in");
|
|
|
|
args.push_back(sigFile);
|
2007-03-01 14:30:46 +01:00
|
|
|
string hash2 = runProgram(OPENSSL_PATH, true, args);
|
2007-03-01 13:30:24 +01:00
|
|
|
|
|
|
|
/* Note: runProgram() throws an exception if the signature
|
|
|
|
is invalid. */
|
|
|
|
|
|
|
|
if (printHash(hash) != hash2)
|
|
|
|
throw Error(
|
|
|
|
"signed hash doesn't match actual contents of imported "
|
|
|
|
"archive; archive could be corrupt, or someone is trying "
|
|
|
|
"to import a Trojan horse");
|
|
|
|
}
|
2007-02-21 16:45:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Do the actual import. */
|
|
|
|
|
|
|
|
/* !!! way too much code duplication with addTextToStore() etc. */
|
|
|
|
addTempRoot(dstPath);
|
|
|
|
|
|
|
|
if (!isValidPath(dstPath)) {
|
|
|
|
|
|
|
|
PathLocks outputLock(singleton<PathSet, Path>(dstPath));
|
|
|
|
|
|
|
|
if (!isValidPath(dstPath)) {
|
|
|
|
|
|
|
|
if (pathExists(dstPath)) deletePathWrapped(dstPath);
|
|
|
|
|
|
|
|
if (rename(unpacked.c_str(), dstPath.c_str()) == -1)
|
|
|
|
throw SysError(format("cannot move `%1%' to `%2%'")
|
|
|
|
% unpacked % dstPath);
|
|
|
|
|
|
|
|
canonicalisePathMetaData(dstPath);
|
|
|
|
|
|
|
|
Transaction txn(nixDB);
|
|
|
|
/* !!! if we were clever, we could prevent the hashPath()
|
|
|
|
here. */
|
2007-02-21 17:23:25 +01:00
|
|
|
if (!isValidPath(deriver)) deriver = "";
|
2007-02-21 16:45:32 +01:00
|
|
|
registerValidPath(txn, dstPath,
|
2007-02-21 17:23:25 +01:00
|
|
|
hashPath(htSHA256, dstPath), references, deriver);
|
2007-02-21 16:45:32 +01:00
|
|
|
txn.commit();
|
|
|
|
}
|
|
|
|
|
|
|
|
outputLock.setDeletion(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dstPath;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-15 22:11:39 +01:00
|
|
|
void deleteFromStore(const Path & _path, unsigned long long & bytesFreed)
|
2003-06-23 16:40:49 +02:00
|
|
|
{
|
2005-12-15 22:11:39 +01:00
|
|
|
bytesFreed = 0;
|
2003-10-08 17:06:59 +02:00
|
|
|
Path path(canonPath(_path));
|
|
|
|
|
2004-02-14 22:44:18 +01:00
|
|
|
assertStorePath(path);
|
2003-07-08 11:54:47 +02:00
|
|
|
|
2003-11-22 19:45:56 +01:00
|
|
|
Transaction txn(nixDB);
|
2005-01-31 15:00:43 +01:00
|
|
|
if (isValidPathTxn(txn, path)) {
|
2005-12-13 22:04:48 +01:00
|
|
|
PathSet referrers = getReferrers(txn, path);
|
|
|
|
for (PathSet::iterator i = referrers.begin();
|
|
|
|
i != referrers.end(); ++i)
|
2005-04-12 12:51:00 +02:00
|
|
|
if (*i != path && isValidPathTxn(txn, *i))
|
2007-01-14 17:24:49 +01:00
|
|
|
throw PathInUse(format("cannot delete path `%1%' because it is in use by path `%2%'") % path % *i);
|
2005-03-03 14:10:44 +01:00
|
|
|
invalidatePath(txn, path);
|
2005-01-31 15:00:43 +01:00
|
|
|
}
|
2003-11-22 19:45:56 +01:00
|
|
|
txn.commit();
|
2003-07-08 11:54:47 +02:00
|
|
|
|
2006-12-09 01:26:24 +01:00
|
|
|
deletePathWrapped(path, bytesFreed);
|
2003-06-23 16:40:49 +02:00
|
|
|
}
|
2003-07-17 14:27:55 +02:00
|
|
|
|
|
|
|
|
2005-02-08 14:48:53 +01:00
|
|
|
void verifyStore(bool checkContents)
|
2003-07-17 14:27:55 +02:00
|
|
|
{
|
2003-07-31 21:49:11 +02:00
|
|
|
Transaction txn(nixDB);
|
|
|
|
|
2007-01-14 18:28:30 +01:00
|
|
|
|
|
|
|
printMsg(lvlInfo, "checking path existence");
|
|
|
|
|
2003-10-10 17:14:29 +02:00
|
|
|
Paths paths;
|
2003-11-22 19:45:56 +01:00
|
|
|
PathSet validPaths;
|
2003-10-10 17:14:29 +02:00
|
|
|
nixDB.enumTable(txn, dbValidPaths, paths);
|
2003-07-17 14:27:55 +02:00
|
|
|
|
2003-12-05 12:05:19 +01:00
|
|
|
for (Paths::iterator i = paths.begin(); i != paths.end(); ++i) {
|
2007-05-01 15:21:05 +02:00
|
|
|
checkInterrupt();
|
2005-02-08 14:48:53 +01:00
|
|
|
if (!pathExists(*i)) {
|
|
|
|
printMsg(lvlError, format("path `%1%' disappeared") % *i);
|
2005-03-03 14:10:44 +01:00
|
|
|
invalidatePath(txn, *i);
|
2005-02-08 14:48:53 +01:00
|
|
|
} else if (!isStorePath(*i)) {
|
|
|
|
printMsg(lvlError, format("path `%1%' is not in the Nix store") % *i);
|
2005-03-03 14:10:44 +01:00
|
|
|
invalidatePath(txn, *i);
|
2005-02-08 14:48:53 +01:00
|
|
|
} else {
|
|
|
|
if (checkContents) {
|
2006-08-01 11:43:41 +02:00
|
|
|
debug(format("checking contents of `%1%'") % *i);
|
2005-02-08 14:48:53 +01:00
|
|
|
Hash expected = queryHash(txn, *i);
|
|
|
|
Hash current = hashPath(expected.type, *i);
|
|
|
|
if (current != expected) {
|
|
|
|
printMsg(lvlError, format("path `%1%' was modified! "
|
|
|
|
"expected hash `%2%', got `%3%'")
|
|
|
|
% *i % printHash(expected) % printHash(current));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
validPaths.insert(*i);
|
|
|
|
}
|
2003-07-17 14:27:55 +02:00
|
|
|
}
|
|
|
|
|
2007-01-14 18:28:30 +01:00
|
|
|
|
2007-08-12 02:29:28 +02:00
|
|
|
/* Check the cleanup invariant: only valid paths can have
|
2005-12-13 22:04:48 +01:00
|
|
|
`references', `referrers', or `derivers' entries. */
|
2005-02-08 14:23:55 +01:00
|
|
|
|
2007-01-14 18:28:30 +01:00
|
|
|
|
2005-02-08 14:23:55 +01:00
|
|
|
/* Check the `derivers' table. */
|
2007-01-14 18:28:30 +01:00
|
|
|
printMsg(lvlInfo, "checking the derivers table");
|
2005-02-08 14:23:55 +01:00
|
|
|
Paths deriversKeys;
|
|
|
|
nixDB.enumTable(txn, dbDerivers, deriversKeys);
|
|
|
|
for (Paths::iterator i = deriversKeys.begin();
|
|
|
|
i != deriversKeys.end(); ++i)
|
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
if (validPaths.find(*i) == validPaths.end()) {
|
|
|
|
printMsg(lvlError, format("removing deriver entry for invalid path `%1%'")
|
2005-02-08 14:23:55 +01:00
|
|
|
% *i);
|
|
|
|
nixDB.delPair(txn, dbDerivers, *i);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Path deriver = queryDeriver(txn, *i);
|
|
|
|
if (!isStorePath(deriver)) {
|
2007-01-14 18:28:30 +01:00
|
|
|
printMsg(lvlError, format("removing corrupt deriver `%1%' for `%2%'")
|
2005-02-08 14:23:55 +01:00
|
|
|
% deriver % *i);
|
|
|
|
nixDB.delPair(txn, dbDerivers, *i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-14 18:28:30 +01:00
|
|
|
|
2005-02-08 14:23:55 +01:00
|
|
|
/* Check the `references' table. */
|
2007-01-14 18:28:30 +01:00
|
|
|
printMsg(lvlInfo, "checking the references table");
|
2005-02-08 14:23:55 +01:00
|
|
|
Paths referencesKeys;
|
|
|
|
nixDB.enumTable(txn, dbReferences, referencesKeys);
|
|
|
|
for (Paths::iterator i = referencesKeys.begin();
|
|
|
|
i != referencesKeys.end(); ++i)
|
|
|
|
{
|
2007-08-12 02:29:28 +02:00
|
|
|
if (validPaths.find(*i) == validPaths.end()) {
|
|
|
|
printMsg(lvlError, format("removing references entry for invalid path `%1%'")
|
2005-02-08 14:23:55 +01:00
|
|
|
% *i);
|
2005-03-25 15:21:49 +01:00
|
|
|
setReferences(txn, *i, PathSet());
|
2005-02-08 14:23:55 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
PathSet references;
|
|
|
|
queryReferences(txn, *i, references);
|
|
|
|
for (PathSet::iterator j = references.begin();
|
|
|
|
j != references.end(); ++j)
|
|
|
|
{
|
2005-12-12 19:24:42 +01:00
|
|
|
string dummy;
|
|
|
|
if (!nixDB.queryString(txn, dbReferrers, addPrefix(*j, *i), dummy)) {
|
2007-01-14 18:28:30 +01:00
|
|
|
printMsg(lvlError, format("adding missing referrer mapping from `%1%' to `%2%'")
|
2005-02-08 14:23:55 +01:00
|
|
|
% *j % *i);
|
2005-12-12 19:24:42 +01:00
|
|
|
nixDB.setString(txn, dbReferrers, addPrefix(*j, *i), "");
|
2005-02-08 14:23:55 +01:00
|
|
|
}
|
2007-08-12 02:29:28 +02:00
|
|
|
if (validPaths.find(*j) == validPaths.end()) {
|
2005-02-09 10:50:29 +01:00
|
|
|
printMsg(lvlError, format("incomplete closure: `%1%' needs missing `%2%'")
|
|
|
|
% *i % *j);
|
|
|
|
}
|
2005-02-08 14:23:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-13 22:04:48 +01:00
|
|
|
/* Check the `referrers' table. */
|
2007-01-14 18:28:30 +01:00
|
|
|
printMsg(lvlInfo, "checking the referrers table");
|
|
|
|
Strings referrers;
|
|
|
|
nixDB.enumTable(txn, dbReferrers, referrers);
|
|
|
|
for (Strings::iterator i = referrers.begin(); i != referrers.end(); ++i) {
|
|
|
|
|
|
|
|
/* Decode the entry (it's a tuple of paths). */
|
|
|
|
string::size_type nul = i->find((char) 0);
|
|
|
|
if (nul == string::npos) {
|
|
|
|
printMsg(lvlError, format("removing bad referrer table entry `%1%'") % *i);
|
|
|
|
nixDB.delPair(txn, dbReferrers, *i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Path to(*i, 0, nul);
|
|
|
|
Path from(*i, nul + 1);
|
|
|
|
|
2007-08-12 02:29:28 +02:00
|
|
|
if (validPaths.find(to) == validPaths.end()) {
|
|
|
|
printMsg(lvlError, format("removing referrer entry from `%1%' to invalid `%2%'")
|
2007-01-14 18:28:30 +01:00
|
|
|
% from % to);
|
|
|
|
nixDB.delPair(txn, dbReferrers, *i);
|
|
|
|
}
|
|
|
|
|
2007-08-12 02:29:28 +02:00
|
|
|
else if (validPaths.find(from) == validPaths.end()) {
|
|
|
|
printMsg(lvlError, format("removing referrer entry from invalid `%1%' to `%2%'")
|
2007-01-14 18:28:30 +01:00
|
|
|
% from % to);
|
2005-12-13 22:04:48 +01:00
|
|
|
nixDB.delPair(txn, dbReferrers, *i);
|
2005-02-08 14:23:55 +01:00
|
|
|
}
|
2007-01-14 18:28:30 +01:00
|
|
|
|
2005-02-08 14:23:55 +01:00
|
|
|
else {
|
2007-01-14 18:28:30 +01:00
|
|
|
PathSet references;
|
|
|
|
queryReferences(txn, from, references);
|
|
|
|
if (find(references.begin(), references.end(), to) == references.end()) {
|
|
|
|
printMsg(lvlError, format("adding missing referrer mapping from `%1%' to `%2%'")
|
|
|
|
% from % to);
|
|
|
|
references.insert(to);
|
|
|
|
setReferences(txn, from, references);
|
2005-02-08 14:23:55 +01:00
|
|
|
}
|
|
|
|
}
|
2007-01-14 18:28:30 +01:00
|
|
|
|
2003-11-24 10:24:52 +01:00
|
|
|
}
|
2003-10-10 17:14:29 +02:00
|
|
|
|
2007-01-14 18:28:30 +01:00
|
|
|
|
2003-07-31 21:49:11 +02:00
|
|
|
txn.commit();
|
2003-07-17 14:27:55 +02:00
|
|
|
}
|
2005-02-09 10:50:29 +01:00
|
|
|
|
|
|
|
|
2007-10-10 00:14:27 +02:00
|
|
|
typedef std::map<Hash, std::pair<Path, ino_t> > HashToPath;
|
|
|
|
|
|
|
|
|
|
|
|
static void toggleWritable(const Path & path, bool writable)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(path.c_str(), &st))
|
|
|
|
throw SysError(format("getting attributes of path `%1%'") % path);
|
|
|
|
|
|
|
|
mode_t mode = st.st_mode;
|
|
|
|
if (writable) mode |= S_IWUSR;
|
|
|
|
else mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
|
|
|
|
|
|
|
|
if (chmod(path.c_str(), mode) == -1)
|
|
|
|
throw SysError(format("changing writability of `%1%'") % path);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void hashAndLink(bool dryRun, HashToPath & hashToPath,
|
|
|
|
OptimiseStats & stats, const Path & path)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(path.c_str(), &st))
|
|
|
|
throw SysError(format("getting attributes of path `%1%'") % path);
|
|
|
|
|
|
|
|
/* Sometimes SNAFUs can cause files in the Nix store to be
|
|
|
|
modified, in particular when running programs as root under
|
|
|
|
NixOS (example: $fontconfig/var/cache being modified). Skip
|
|
|
|
those files. */
|
|
|
|
if (S_ISREG(st.st_mode) && (st.st_mode & S_IWUSR)) {
|
|
|
|
printMsg(lvlError, format("skipping suspicious writable file `%1%'") % path);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We can hard link regular files and symlinks. */
|
|
|
|
if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
|
|
|
|
|
|
|
|
/* Hash the file. Note that hashPath() returns the hash over
|
|
|
|
the NAR serialisation, which includes the execute bit on
|
|
|
|
the file. Thus, executable and non-executable files with
|
|
|
|
the same contents *won't* be linked (which is good because
|
|
|
|
otherwise the permissions would be screwed up).
|
|
|
|
|
|
|
|
Also note that if `path' is a symlink, then we're hashing
|
|
|
|
the contents of the symlink (i.e. the result of
|
|
|
|
readlink()), not the contents of the target (which may not
|
|
|
|
even exist). */
|
|
|
|
Hash hash = hashPath(htSHA256, path);
|
|
|
|
stats.totalFiles++;
|
|
|
|
printMsg(lvlDebug, format("`%1%' has hash `%2%'") % path % printHash(hash));
|
|
|
|
|
|
|
|
std::pair<Path, ino_t> prevPath = hashToPath[hash];
|
|
|
|
|
|
|
|
if (prevPath.first == "") {
|
|
|
|
hashToPath[hash] = std::pair<Path, ino_t>(path, st.st_ino);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Yes! We've seen a file with the same contents. Replace
|
|
|
|
the current file with a hard link to that file. */
|
|
|
|
stats.sameContents++;
|
|
|
|
if (prevPath.second == st.st_ino) {
|
|
|
|
printMsg(lvlDebug, format("`%1%' is already linked to `%2%'") % path % prevPath.first);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-10-10 15:43:04 +02:00
|
|
|
if (!dryRun) {
|
|
|
|
|
|
|
|
printMsg(lvlTalkative, format("linking `%1%' to `%2%'") % path % prevPath.first);
|
2007-10-10 00:14:27 +02:00
|
|
|
|
2007-10-10 15:43:04 +02:00
|
|
|
Path tempLink = (format("%1%.tmp-%2%-%3%")
|
|
|
|
% path % getpid() % rand()).str();
|
2007-10-10 00:14:27 +02:00
|
|
|
|
2007-10-10 15:43:04 +02:00
|
|
|
toggleWritable(dirOf(path), true);
|
2007-10-10 00:14:27 +02:00
|
|
|
|
2007-10-10 15:43:04 +02:00
|
|
|
if (link(prevPath.first.c_str(), tempLink.c_str()) == -1)
|
|
|
|
throw SysError(format("cannot link `%1%' to `%2%'")
|
|
|
|
% tempLink % prevPath.first);
|
|
|
|
|
|
|
|
/* Atomically replace the old file with the new hard link. */
|
|
|
|
if (rename(tempLink.c_str(), path.c_str()) == -1)
|
|
|
|
throw SysError(format("cannot rename `%1%' to `%2%'")
|
|
|
|
% tempLink % path);
|
|
|
|
|
|
|
|
/* Make the directory read-only again and reset its
|
|
|
|
timestamp back to 0. */
|
|
|
|
_canonicalisePathMetaData(dirOf(path), false);
|
|
|
|
|
|
|
|
} else
|
|
|
|
printMsg(lvlTalkative, format("would link `%1%' to `%2%'") % path % prevPath.first);
|
2007-10-10 00:14:27 +02:00
|
|
|
|
|
|
|
stats.filesLinked++;
|
|
|
|
stats.bytesFreed += st.st_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
Strings names = readDirectory(path);
|
|
|
|
for (Strings::iterator i = names.begin(); i != names.end(); ++i)
|
|
|
|
hashAndLink(dryRun, hashToPath, stats, path + "/" + *i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LocalStore::optimiseStore(bool dryRun, OptimiseStats & stats)
|
|
|
|
{
|
|
|
|
HashToPath hashToPath;
|
|
|
|
|
|
|
|
Paths paths;
|
|
|
|
PathSet validPaths;
|
|
|
|
nixDB.enumTable(noTxn, dbValidPaths, paths);
|
|
|
|
|
|
|
|
for (Paths::iterator i = paths.begin(); i != paths.end(); ++i) {
|
|
|
|
addTempRoot(*i);
|
|
|
|
if (!isValidPath(*i)) continue; /* path was GC'ed, probably */
|
|
|
|
startNest(nest, lvlChatty, format("hashing files in `%1%'") % *i);
|
|
|
|
hashAndLink(dryRun, hashToPath, stats, *i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-09 10:50:29 +01:00
|
|
|
/* Upgrade from schema 1 (Nix <= 0.7) to schema 2 (Nix >= 0.8). */
|
2005-12-12 19:24:42 +01:00
|
|
|
static void upgradeStore07()
|
2005-02-09 10:50:29 +01:00
|
|
|
{
|
|
|
|
printMsg(lvlError, "upgrading Nix store to new schema (this may take a while)...");
|
|
|
|
|
|
|
|
Transaction txn(nixDB);
|
|
|
|
|
|
|
|
Paths validPaths2;
|
|
|
|
nixDB.enumTable(txn, dbValidPaths, validPaths2);
|
|
|
|
PathSet validPaths(validPaths2.begin(), validPaths2.end());
|
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << "hashing paths...";
|
2005-02-09 15:37:24 +01:00
|
|
|
int n = 0;
|
2005-02-09 10:50:29 +01:00
|
|
|
for (PathSet::iterator i = validPaths.begin(); i != validPaths.end(); ++i) {
|
|
|
|
checkInterrupt();
|
|
|
|
string s;
|
|
|
|
nixDB.queryString(txn, dbValidPaths, *i, s);
|
|
|
|
if (s == "") {
|
|
|
|
Hash hash = hashPath(htSHA256, *i);
|
|
|
|
setHash(txn, *i, hash);
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << ".";
|
2005-02-09 15:37:24 +01:00
|
|
|
if (++n % 1000 == 0) {
|
|
|
|
txn.commit();
|
|
|
|
txn.begin(nixDB);
|
|
|
|
}
|
2005-02-09 10:50:29 +01:00
|
|
|
}
|
|
|
|
}
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << std::endl;
|
2005-02-09 10:50:29 +01:00
|
|
|
|
2005-02-09 15:37:24 +01:00
|
|
|
txn.commit();
|
|
|
|
|
|
|
|
txn.begin(nixDB);
|
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << "processing closures...";
|
2005-02-09 10:50:29 +01:00
|
|
|
for (PathSet::iterator i = validPaths.begin(); i != validPaths.end(); ++i) {
|
|
|
|
checkInterrupt();
|
|
|
|
if (i->size() > 6 && string(*i, i->size() - 6) == ".store") {
|
|
|
|
ATerm t = ATreadFromNamedFile(i->c_str());
|
|
|
|
if (!t) throw Error(format("cannot read aterm from `%1%'") % *i);
|
|
|
|
|
|
|
|
ATermList roots, elems;
|
|
|
|
if (!matchOldClosure(t, roots, elems)) continue;
|
|
|
|
|
|
|
|
for (ATermIterator j(elems); j; ++j) {
|
|
|
|
|
|
|
|
ATerm path2;
|
|
|
|
ATermList references2;
|
|
|
|
if (!matchOldClosureElem(*j, path2, references2)) continue;
|
|
|
|
|
|
|
|
Path path = aterm2String(path2);
|
|
|
|
if (validPaths.find(path) == validPaths.end())
|
|
|
|
/* Skip this path; it's invalid. This is a normal
|
|
|
|
condition (Nix <= 0.7 did not enforce closure
|
|
|
|
on closure store expressions). */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
PathSet references;
|
|
|
|
for (ATermIterator k(references2); k; ++k) {
|
|
|
|
Path reference = aterm2String(*k);
|
|
|
|
if (validPaths.find(reference) == validPaths.end())
|
|
|
|
/* Bad reference. Set it anyway and let the
|
|
|
|
user fix it. */
|
|
|
|
printMsg(lvlError, format("closure `%1%' contains reference from `%2%' "
|
|
|
|
"to invalid path `%3%' (run `nix-store --verify')")
|
|
|
|
% *i % path % reference);
|
|
|
|
references.insert(reference);
|
|
|
|
}
|
|
|
|
|
|
|
|
PathSet prevReferences;
|
|
|
|
queryReferences(txn, path, prevReferences);
|
|
|
|
if (prevReferences.size() > 0 && references != prevReferences)
|
|
|
|
printMsg(lvlError, format("warning: conflicting references for `%1%'") % path);
|
|
|
|
|
|
|
|
if (references != prevReferences)
|
|
|
|
setReferences(txn, path, references);
|
|
|
|
}
|
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << ".";
|
2005-02-09 10:50:29 +01:00
|
|
|
}
|
|
|
|
}
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << std::endl;
|
2005-02-09 10:50:29 +01:00
|
|
|
|
|
|
|
/* !!! maybe this transaction is way too big */
|
|
|
|
txn.commit();
|
|
|
|
}
|
2005-12-12 19:24:42 +01:00
|
|
|
|
|
|
|
|
|
|
|
/* Upgrade from schema 2 (0.8 <= Nix <= 0.9) to schema 3 (Nix >=
|
|
|
|
0.10). The only thing to do here is to upgrade the old `referer'
|
|
|
|
table (which causes quadratic complexity in some cases) to the new
|
|
|
|
(and properly spelled) `referrer' table. */
|
|
|
|
static void upgradeStore09()
|
|
|
|
{
|
2005-12-15 17:53:21 +01:00
|
|
|
/* !!! we should disallow concurrent upgrades */
|
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
if (!pathExists(nixDBPath + "/referers")) return;
|
|
|
|
|
2007-08-13 13:37:39 +02:00
|
|
|
printMsg(lvlError, "upgrading Nix store to new schema (this may take a while)...");
|
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
Transaction txn(nixDB);
|
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << "converting referers to referrers...";
|
2005-12-12 19:24:42 +01:00
|
|
|
|
|
|
|
TableId dbReferers = nixDB.openTable("referers"); /* sic! */
|
|
|
|
|
|
|
|
Paths referersKeys;
|
|
|
|
nixDB.enumTable(txn, dbReferers, referersKeys);
|
2005-12-15 17:53:21 +01:00
|
|
|
|
|
|
|
int n = 0;
|
2005-12-12 19:24:42 +01:00
|
|
|
for (Paths::iterator i = referersKeys.begin();
|
|
|
|
i != referersKeys.end(); ++i)
|
|
|
|
{
|
|
|
|
Paths referers;
|
|
|
|
nixDB.queryStrings(txn, dbReferers, *i, referers);
|
|
|
|
for (Paths::iterator j = referers.begin();
|
|
|
|
j != referers.end(); ++j)
|
|
|
|
nixDB.setString(txn, dbReferrers, addPrefix(*i, *j), "");
|
2005-12-15 17:53:21 +01:00
|
|
|
if (++n % 1000 == 0) {
|
|
|
|
txn.commit();
|
|
|
|
txn.begin(nixDB);
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << "|";
|
2005-12-15 17:53:21 +01:00
|
|
|
}
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << ".";
|
2005-12-12 19:24:42 +01:00
|
|
|
}
|
2005-12-12 20:14:38 +01:00
|
|
|
|
2005-12-12 19:24:42 +01:00
|
|
|
txn.commit();
|
2005-12-15 17:53:21 +01:00
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
std::cerr << std::endl;
|
2005-12-12 20:14:38 +01:00
|
|
|
|
|
|
|
nixDB.closeTable(dbReferers);
|
|
|
|
|
|
|
|
nixDB.deleteTable("referers");
|
2005-12-12 19:24:42 +01:00
|
|
|
}
|
2006-09-04 23:06:23 +02:00
|
|
|
|
|
|
|
|
2007-08-13 13:37:39 +02:00
|
|
|
/* Upgrade from schema 3 (Nix 0.10) to schema 4 (Nix >= 0.11). The
|
|
|
|
only thing to do here is to delete the substitutes table and get
|
|
|
|
rid of invalid but substitutable references/referrers. */
|
|
|
|
static void upgradeStore11()
|
|
|
|
{
|
|
|
|
if (!pathExists(nixDBPath + "/substitutes")) return;
|
|
|
|
|
|
|
|
printMsg(lvlError, "upgrading Nix store to new schema (this may take a while)...");
|
|
|
|
|
|
|
|
Transaction txn(nixDB);
|
|
|
|
TableId dbSubstitutes = nixDB.openTable("substitutes");
|
|
|
|
|
|
|
|
Paths subKeys;
|
|
|
|
nixDB.enumTable(txn, dbSubstitutes, subKeys);
|
|
|
|
for (Paths::iterator i = subKeys.begin(); i != subKeys.end(); ++i) {
|
|
|
|
if (!isValidPathTxn(txn, *i))
|
|
|
|
invalidatePath(txn, *i);
|
|
|
|
}
|
|
|
|
|
|
|
|
txn.commit();
|
|
|
|
nixDB.closeTable(dbSubstitutes);
|
|
|
|
nixDB.deleteTable("substitutes");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-09-04 23:06:23 +02:00
|
|
|
}
|