2016-03-24 11:41:00 +01:00
|
|
|
|
#include "crypto.hh"
|
2006-11-30 18:43:04 +01:00
|
|
|
|
#include "globals.hh"
|
2016-03-24 11:41:00 +01:00
|
|
|
|
#include "store-api.hh"
|
2006-11-30 19:35:36 +01:00
|
|
|
|
#include "util.hh"
|
2016-04-20 14:12:38 +02:00
|
|
|
|
#include "nar-info-disk-cache.hh"
|
2006-11-30 18:43:04 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool isInStore(const Path & path)
|
|
|
|
|
{
|
2013-07-12 14:01:25 +02:00
|
|
|
|
return isInDir(path, settings.nixStore);
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool isStorePath(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
return isInStore(path)
|
2016-04-21 18:21:25 +02:00
|
|
|
|
&& path.size() >= settings.nixStore.size() + 1 + storePathHashLen
|
2012-07-31 01:55:41 +02:00
|
|
|
|
&& path.find('/', settings.nixStore.size() + 1) == Path::npos;
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void assertStorePath(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
if (!isStorePath(path))
|
2014-08-20 17:00:17 +02:00
|
|
|
|
throw Error(format("path ‘%1%’ is not in the Nix store") % path);
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Path toStorePath(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
if (!isInStore(path))
|
2014-08-20 17:00:17 +02:00
|
|
|
|
throw Error(format("path ‘%1%’ is not in the Nix store") % path);
|
2012-07-31 01:55:41 +02:00
|
|
|
|
Path::size_type slash = path.find('/', settings.nixStore.size() + 1);
|
2006-11-30 18:43:04 +01:00
|
|
|
|
if (slash == Path::npos)
|
|
|
|
|
return path;
|
|
|
|
|
else
|
|
|
|
|
return Path(path, 0, slash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2007-11-29 17:18:24 +01:00
|
|
|
|
Path followLinksToStore(const Path & _path)
|
|
|
|
|
{
|
|
|
|
|
Path path = absPath(_path);
|
|
|
|
|
while (!isInStore(path)) {
|
|
|
|
|
if (!isLink(path)) break;
|
|
|
|
|
string target = readLink(path);
|
|
|
|
|
path = absPath(target, dirOf(path));
|
|
|
|
|
}
|
|
|
|
|
if (!isInStore(path))
|
2014-08-20 17:00:17 +02:00
|
|
|
|
throw Error(format("path ‘%1%’ is not in the Nix store") % path);
|
2007-11-29 17:18:24 +01:00
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Path followLinksToStorePath(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
return toStorePath(followLinksToStore(path));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-07-20 20:10:47 +02:00
|
|
|
|
string storePathToName(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
assertStorePath(path);
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto l = settings.nixStore.size() + 1 + storePathHashLen;
|
|
|
|
|
assert(path.size() >= l);
|
|
|
|
|
return path.size() == l ? "" : string(path, l + 1);
|
2016-02-15 12:49:01 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
string storePathToHash(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
assertStorePath(path);
|
2016-04-21 17:53:47 +02:00
|
|
|
|
assert(path.size() >= settings.nixStore.size() + 1 + storePathHashLen);
|
2016-02-15 12:49:01 +01:00
|
|
|
|
return string(path, settings.nixStore.size() + 1, storePathHashLen);
|
2011-07-20 20:10:47 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
|
void checkStoreName(const string & name)
|
|
|
|
|
{
|
|
|
|
|
string validChars = "+-._?=";
|
|
|
|
|
/* Disallow names starting with a dot for possible security
|
|
|
|
|
reasons (e.g., "." and ".."). */
|
|
|
|
|
if (string(name, 0, 1) == ".")
|
2014-08-20 17:00:17 +02:00
|
|
|
|
throw Error(format("illegal name: ‘%1%’") % name);
|
2015-07-17 19:24:28 +02:00
|
|
|
|
for (auto & i : name)
|
|
|
|
|
if (!((i >= 'A' && i <= 'Z') ||
|
|
|
|
|
(i >= 'a' && i <= 'z') ||
|
|
|
|
|
(i >= '0' && i <= '9') ||
|
|
|
|
|
validChars.find(i) != string::npos))
|
2006-11-30 18:43:04 +01:00
|
|
|
|
{
|
2014-08-20 17:00:17 +02:00
|
|
|
|
throw Error(format("invalid character ‘%1%’ in name ‘%2%’")
|
2015-07-17 19:24:28 +02:00
|
|
|
|
% i % name);
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
/* Store paths have the following form:
|
|
|
|
|
|
|
|
|
|
<store>/<h>-<name>
|
|
|
|
|
|
|
|
|
|
where
|
|
|
|
|
|
|
|
|
|
<store> = the location of the Nix store, usually /nix/store
|
2015-07-17 19:24:28 +02:00
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
<name> = a human readable name for the path, typically obtained
|
|
|
|
|
from the name attribute of the derivation, or the name of the
|
2011-07-20 20:10:47 +02:00
|
|
|
|
source file from which the store path is created. For derivation
|
|
|
|
|
outputs other than the default "out" output, the string "-<id>"
|
|
|
|
|
is suffixed to <name>.
|
2015-07-17 19:24:28 +02:00
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
<h> = base-32 representation of the first 160 bits of a SHA-256
|
|
|
|
|
hash of <s>; the hash part of the store name
|
2015-07-17 19:24:28 +02:00
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
<s> = the string "<type>:sha256:<h2>:<store>:<name>";
|
|
|
|
|
note that it includes the location of the store as well as the
|
|
|
|
|
name to make sure that changes to either of those are reflected
|
|
|
|
|
in the hash (e.g. you won't get /nix/store/<h>-name1 and
|
|
|
|
|
/nix/store/<h>-name2 with equal hash parts).
|
2015-07-17 19:24:28 +02:00
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
<type> = one of:
|
|
|
|
|
"text:<r1>:<r2>:...<rN>"
|
|
|
|
|
for plain text files written to the store using
|
|
|
|
|
addTextToStore(); <r1> ... <rN> are the references of the
|
|
|
|
|
path.
|
|
|
|
|
"source"
|
|
|
|
|
for paths copied to the store using addToStore() when recursive
|
|
|
|
|
= true and hashAlgo = "sha256"
|
2011-07-20 20:10:47 +02:00
|
|
|
|
"output:<id>"
|
2008-12-03 16:06:30 +01:00
|
|
|
|
for either the outputs created by derivations, OR paths copied
|
|
|
|
|
to the store using addToStore() with recursive != true or
|
|
|
|
|
hashAlgo != "sha256" (in that case "source" is used; it's
|
2011-07-20 20:10:47 +02:00
|
|
|
|
silly, but it's done that way for compatibility). <id> is the
|
|
|
|
|
name of the output (usually, "out").
|
2008-12-03 16:06:30 +01:00
|
|
|
|
|
|
|
|
|
<h2> = base-16 representation of a SHA-256 hash of:
|
|
|
|
|
if <type> = "text:...":
|
|
|
|
|
the string written to the resulting store path
|
|
|
|
|
if <type> = "source":
|
|
|
|
|
the serialisation of the path from which this store path is
|
|
|
|
|
copied, as returned by hashPath()
|
2016-03-24 11:27:58 +01:00
|
|
|
|
if <type> = "output:<id>":
|
2008-12-03 16:06:30 +01:00
|
|
|
|
for non-fixed derivation outputs:
|
|
|
|
|
the derivation (see hashDerivationModulo() in
|
|
|
|
|
primops.cc)
|
|
|
|
|
for paths copied by addToStore() or produced by fixed-output
|
|
|
|
|
derivations:
|
|
|
|
|
the string "fixed:out:<rec><algo>:<hash>:", where
|
2016-03-24 11:27:58 +01:00
|
|
|
|
<rec> = "r:" for recursive (path) hashes, or "" for flat
|
2008-12-03 16:06:30 +01:00
|
|
|
|
(file) hashes
|
|
|
|
|
<algo> = "md5", "sha1" or "sha256"
|
|
|
|
|
<hash> = base-16 representation of the path or flat hash of
|
|
|
|
|
the contents of the path (or expected contents of the
|
|
|
|
|
path for fixed-output derivations)
|
|
|
|
|
|
|
|
|
|
It would have been nicer to handle fixed-output derivations under
|
|
|
|
|
"source", e.g. have something like "source:<rec><algo>", but we're
|
|
|
|
|
stuck with this for now...
|
|
|
|
|
|
|
|
|
|
The main reason for this way of computing names is to prevent name
|
|
|
|
|
collisions (for security). For instance, it shouldn't be feasible
|
|
|
|
|
to come up with a derivation whose output path collides with the
|
|
|
|
|
path for a copied source. The former would have a <s> starting with
|
|
|
|
|
"output:out:", while the latter would have a <2> starting with
|
|
|
|
|
"source:".
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
|
Path makeStorePath(const string & type,
|
2008-12-03 16:06:30 +01:00
|
|
|
|
const Hash & hash, const string & name)
|
2006-11-30 18:43:04 +01:00
|
|
|
|
{
|
|
|
|
|
/* e.g., "source:sha256:1abc...:/nix/store:foo.tar.gz" */
|
|
|
|
|
string s = type + ":sha256:" + printHash(hash) + ":"
|
2012-07-31 01:55:41 +02:00
|
|
|
|
+ settings.nixStore + ":" + name;
|
2006-11-30 18:43:04 +01:00
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
checkStoreName(name);
|
2006-11-30 18:43:04 +01:00
|
|
|
|
|
2012-07-31 01:55:41 +02:00
|
|
|
|
return settings.nixStore + "/"
|
2006-11-30 18:43:04 +01:00
|
|
|
|
+ printHash32(compressHash(hashString(htSHA256, s), 20))
|
2008-12-03 16:06:30 +01:00
|
|
|
|
+ "-" + name;
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-07-20 20:10:47 +02:00
|
|
|
|
Path makeOutputPath(const string & id,
|
|
|
|
|
const Hash & hash, const string & name)
|
|
|
|
|
{
|
|
|
|
|
return makeStorePath("output:" + id, hash,
|
|
|
|
|
name + (id == "out" ? "" : "-" + id));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
|
Path makeFixedOutputPath(bool recursive,
|
2008-12-03 17:10:17 +01:00
|
|
|
|
HashType hashAlgo, Hash hash, string name)
|
2006-11-30 18:43:04 +01:00
|
|
|
|
{
|
2008-12-03 17:10:17 +01:00
|
|
|
|
return hashAlgo == htSHA256 && recursive
|
2008-12-03 16:06:30 +01:00
|
|
|
|
? makeStorePath("source", hash, name)
|
|
|
|
|
: makeStorePath("output:out", hashString(htSHA256,
|
2008-12-03 17:10:17 +01:00
|
|
|
|
"fixed:out:" + (recursive ? (string) "r:" : "") +
|
|
|
|
|
printHashType(hashAlgo) + ":" + printHash(hash) + ":"),
|
2008-12-03 16:06:30 +01:00
|
|
|
|
name);
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
2006-12-01 19:00:01 +01:00
|
|
|
|
|
2006-12-01 21:51:18 +01:00
|
|
|
|
std::pair<Path, Hash> computeStorePathForPath(const Path & srcPath,
|
2008-12-03 17:10:17 +01:00
|
|
|
|
bool recursive, HashType hashAlgo, PathFilter & filter)
|
2006-12-01 19:00:01 +01:00
|
|
|
|
{
|
2008-12-03 17:10:17 +01:00
|
|
|
|
HashType ht(hashAlgo);
|
2010-11-16 18:11:46 +01:00
|
|
|
|
Hash h = recursive ? hashPath(ht, srcPath, filter).first : hashFile(ht, srcPath);
|
2008-12-03 16:06:30 +01:00
|
|
|
|
string name = baseNameOf(srcPath);
|
|
|
|
|
Path dstPath = makeFixedOutputPath(recursive, hashAlgo, h, name);
|
2006-12-01 19:00:01 +01:00
|
|
|
|
return std::pair<Path, Hash>(dstPath, h);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-12-03 16:06:30 +01:00
|
|
|
|
Path computeStorePathForText(const string & name, const string & s,
|
2007-01-29 16:51:37 +01:00
|
|
|
|
const PathSet & references)
|
2006-12-01 19:00:01 +01:00
|
|
|
|
{
|
|
|
|
|
Hash hash = hashString(htSHA256, s);
|
2007-01-29 16:51:37 +01:00
|
|
|
|
/* Stuff the references (if any) into the type. This is a bit
|
|
|
|
|
hacky, but we can't put them in `s' since that would be
|
|
|
|
|
ambiguous. */
|
|
|
|
|
string type = "text";
|
2015-07-17 19:24:28 +02:00
|
|
|
|
for (auto & i : references) {
|
2007-01-29 16:51:37 +01:00
|
|
|
|
type += ":";
|
2015-07-17 19:24:28 +02:00
|
|
|
|
type += i;
|
2007-01-29 16:51:37 +01:00
|
|
|
|
}
|
2008-12-03 16:06:30 +01:00
|
|
|
|
return makeStorePath(type, hash, name);
|
2006-12-01 19:00:01 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-20 14:12:38 +02:00
|
|
|
|
std::string Store::getUri()
|
|
|
|
|
{
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
bool Store::isValidPath(const Path & storePath)
|
2016-02-15 14:48:38 +01:00
|
|
|
|
{
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto hashPart = storePathToHash(storePath);
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto res = state_->pathInfoCache.get(hashPart);
|
2016-04-19 18:50:15 +02:00
|
|
|
|
if (res) {
|
|
|
|
|
stats.narInfoReadAverted++;
|
|
|
|
|
return *res != 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-20 14:12:38 +02:00
|
|
|
|
if (diskCache) {
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto res = diskCache->lookupNarInfo(getUri(), hashPart);
|
2016-04-20 14:12:38 +02:00
|
|
|
|
if (res.first != NarInfoDiskCache::oUnknown) {
|
2016-04-21 17:53:47 +02:00
|
|
|
|
stats.narInfoReadAverted++;
|
2016-04-20 14:12:38 +02:00
|
|
|
|
auto state_(state.lock());
|
2016-04-21 17:53:47 +02:00
|
|
|
|
state_->pathInfoCache.upsert(hashPart,
|
2016-04-20 14:12:38 +02:00
|
|
|
|
res.first == NarInfoDiskCache::oInvalid ? 0 : res.second);
|
|
|
|
|
return res.first == NarInfoDiskCache::oValid;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
return isValidPathUncached(storePath);
|
2016-04-20 14:12:38 +02:00
|
|
|
|
|
|
|
|
|
// FIXME: insert result into NARExistence table of diskCache.
|
2016-04-19 18:50:15 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ref<const ValidPathInfo> Store::queryPathInfo(const Path & storePath)
|
|
|
|
|
{
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto hashPart = storePathToHash(storePath);
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto res = state_->pathInfoCache.get(hashPart);
|
2016-04-19 18:50:15 +02:00
|
|
|
|
if (res) {
|
|
|
|
|
stats.narInfoReadAverted++;
|
|
|
|
|
if (!*res)
|
|
|
|
|
throw InvalidPath(format("path ‘%s’ is not valid") % storePath);
|
|
|
|
|
return ref<ValidPathInfo>(*res);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-20 14:12:38 +02:00
|
|
|
|
if (diskCache) {
|
2016-04-21 17:53:47 +02:00
|
|
|
|
auto res = diskCache->lookupNarInfo(getUri(), hashPart);
|
2016-04-20 14:12:38 +02:00
|
|
|
|
if (res.first != NarInfoDiskCache::oUnknown) {
|
2016-04-21 17:53:47 +02:00
|
|
|
|
stats.narInfoReadAverted++;
|
2016-04-20 14:12:38 +02:00
|
|
|
|
auto state_(state.lock());
|
2016-04-21 17:53:47 +02:00
|
|
|
|
state_->pathInfoCache.upsert(hashPart,
|
2016-04-20 14:12:38 +02:00
|
|
|
|
res.first == NarInfoDiskCache::oInvalid ? 0 : res.second);
|
2016-04-21 17:53:47 +02:00
|
|
|
|
if (res.first == NarInfoDiskCache::oInvalid ||
|
|
|
|
|
(res.second->path != storePath && storePathToName(storePath) != ""))
|
2016-04-20 14:12:38 +02:00
|
|
|
|
throw InvalidPath(format("path ‘%s’ is not valid") % storePath);
|
|
|
|
|
return ref<ValidPathInfo>(res.second);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
auto info = queryPathInfoUncached(storePath);
|
|
|
|
|
|
2016-04-20 14:12:38 +02:00
|
|
|
|
if (diskCache && info)
|
2016-04-21 17:53:47 +02:00
|
|
|
|
diskCache->upsertNarInfo(getUri(), hashPart, info);
|
2016-04-20 14:12:38 +02:00
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
2016-04-21 17:53:47 +02:00
|
|
|
|
state_->pathInfoCache.upsert(hashPart, info);
|
2016-04-19 18:50:15 +02:00
|
|
|
|
}
|
|
|
|
|
|
2016-04-21 17:53:47 +02:00
|
|
|
|
if (!info
|
|
|
|
|
|| (info->path != storePath && storePathToName(storePath) != ""))
|
|
|
|
|
{
|
2016-04-19 18:50:15 +02:00
|
|
|
|
stats.narInfoMissing++;
|
|
|
|
|
throw InvalidPath(format("path ‘%s’ is not valid") % storePath);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ref<ValidPathInfo>(info);
|
2016-02-15 14:48:38 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-01-29 19:17:36 +01:00
|
|
|
|
/* Return a string accepted by decodeValidPathInfo() that
|
|
|
|
|
registers the specified paths as valid. Note: it's the
|
|
|
|
|
responsibility of the caller to provide a closure. */
|
2016-02-04 14:48:42 +01:00
|
|
|
|
string Store::makeValidityRegistration(const PathSet & paths,
|
2008-01-29 19:17:36 +01:00
|
|
|
|
bool showDerivers, bool showHash)
|
|
|
|
|
{
|
|
|
|
|
string s = "";
|
|
|
|
|
|
2015-07-17 19:24:28 +02:00
|
|
|
|
for (auto & i : paths) {
|
|
|
|
|
s += i + "\n";
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
auto info = queryPathInfo(i);
|
2008-01-29 19:17:36 +01:00
|
|
|
|
|
2010-11-16 18:11:46 +01:00
|
|
|
|
if (showHash) {
|
2016-04-19 18:50:15 +02:00
|
|
|
|
s += printHash(info->narHash) + "\n";
|
|
|
|
|
s += (format("%1%\n") % info->narSize).str();
|
2010-11-16 18:11:46 +01:00
|
|
|
|
}
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
Path deriver = showDerivers ? info->deriver : "";
|
2008-01-29 19:17:36 +01:00
|
|
|
|
s += deriver + "\n";
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
s += (format("%1%\n") % info->references.size()).str();
|
2008-01-29 19:17:36 +01:00
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
for (auto & j : info->references)
|
2015-07-17 19:24:28 +02:00
|
|
|
|
s += j + "\n";
|
2008-01-29 19:17:36 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-19 18:50:15 +02:00
|
|
|
|
const Store::Stats & Store::getStats()
|
|
|
|
|
{
|
2016-04-20 14:12:38 +02:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
|
|
|
|
stats.pathInfoCacheSize = state_->pathInfoCache.size();
|
|
|
|
|
}
|
2016-04-19 18:50:15 +02:00
|
|
|
|
return stats;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-05-03 14:45:50 +02:00
|
|
|
|
void copyStorePath(ref<Store> srcStore, ref<Store> dstStore,
|
|
|
|
|
const Path & storePath)
|
|
|
|
|
{
|
|
|
|
|
auto info = srcStore->queryPathInfo(storePath);
|
|
|
|
|
|
|
|
|
|
StringSink sink;
|
|
|
|
|
srcStore->exportPaths({storePath}, false, sink);
|
|
|
|
|
|
|
|
|
|
StringSource source(*sink.s);
|
|
|
|
|
dstStore->importPaths(false, source, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-01-29 19:17:36 +01:00
|
|
|
|
ValidPathInfo decodeValidPathInfo(std::istream & str, bool hashGiven)
|
2007-08-12 02:29:28 +02:00
|
|
|
|
{
|
|
|
|
|
ValidPathInfo info;
|
|
|
|
|
getline(str, info.path);
|
|
|
|
|
if (str.eof()) { info.path = ""; return info; }
|
2008-01-29 19:17:36 +01:00
|
|
|
|
if (hashGiven) {
|
|
|
|
|
string s;
|
|
|
|
|
getline(str, s);
|
2016-02-16 11:49:12 +01:00
|
|
|
|
info.narHash = parseHash(htSHA256, s);
|
2010-11-16 18:11:46 +01:00
|
|
|
|
getline(str, s);
|
|
|
|
|
if (!string2Int(s, info.narSize)) throw Error("number expected");
|
2008-01-29 19:17:36 +01:00
|
|
|
|
}
|
2007-08-12 02:29:28 +02:00
|
|
|
|
getline(str, info.deriver);
|
|
|
|
|
string s; int n;
|
|
|
|
|
getline(str, s);
|
|
|
|
|
if (!string2Int(s, n)) throw Error("number expected");
|
|
|
|
|
while (n--) {
|
|
|
|
|
getline(str, s);
|
|
|
|
|
info.references.insert(s);
|
|
|
|
|
}
|
|
|
|
|
if (!str || str.eof()) throw Error("missing input");
|
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-06-09 15:52:45 +02:00
|
|
|
|
string showPaths(const PathSet & paths)
|
|
|
|
|
{
|
|
|
|
|
string s;
|
2015-07-17 19:24:28 +02:00
|
|
|
|
for (auto & i : paths) {
|
2008-06-09 15:52:45 +02:00
|
|
|
|
if (s.size() != 0) s += ", ";
|
2015-07-17 19:24:28 +02:00
|
|
|
|
s += "‘" + i + "’";
|
2008-06-09 15:52:45 +02:00
|
|
|
|
}
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-02-04 14:48:42 +01:00
|
|
|
|
void Store::exportPaths(const Paths & paths,
|
2011-11-23 16:13:37 +01:00
|
|
|
|
bool sign, Sink & sink)
|
|
|
|
|
{
|
2015-07-17 19:24:28 +02:00
|
|
|
|
for (auto & i : paths) {
|
2015-07-20 01:16:16 +02:00
|
|
|
|
sink << 1;
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 14:28:26 +01:00
|
|
|
|
exportPath(i, sign, sink);
|
2011-11-23 16:13:37 +01:00
|
|
|
|
}
|
2015-07-20 01:16:16 +02:00
|
|
|
|
sink << 0;
|
2011-11-23 16:13:37 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-03-24 11:41:00 +01:00
|
|
|
|
std::string ValidPathInfo::fingerprint() const
|
|
|
|
|
{
|
2016-04-20 14:12:38 +02:00
|
|
|
|
if (narSize == 0 || !narHash)
|
2016-04-05 16:39:29 +02:00
|
|
|
|
throw Error(format("cannot calculate fingerprint of path ‘%s’ because its size/hash is not known")
|
|
|
|
|
% path);
|
2016-03-24 11:41:00 +01:00
|
|
|
|
return
|
|
|
|
|
"1;" + path + ";"
|
|
|
|
|
+ printHashType(narHash.type) + ":" + printHash32(narHash) + ";"
|
|
|
|
|
+ std::to_string(narSize) + ";"
|
|
|
|
|
+ concatStringsSep(",", references);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ValidPathInfo::sign(const SecretKey & secretKey)
|
|
|
|
|
{
|
|
|
|
|
sigs.insert(secretKey.signDetached(fingerprint()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
unsigned int ValidPathInfo::checkSignatures(const PublicKeys & publicKeys) const
|
|
|
|
|
{
|
|
|
|
|
unsigned int good = 0;
|
|
|
|
|
for (auto & sig : sigs)
|
2016-04-07 15:14:12 +02:00
|
|
|
|
if (checkSignature(publicKeys, sig))
|
2016-03-24 11:41:00 +01:00
|
|
|
|
good++;
|
|
|
|
|
return good;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-07 15:14:12 +02:00
|
|
|
|
bool ValidPathInfo::checkSignature(const PublicKeys & publicKeys, const std::string & sig) const
|
|
|
|
|
{
|
|
|
|
|
return verifyDetached(fingerprint(), sig, publicKeys);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-20 14:12:38 +02:00
|
|
|
|
Strings ValidPathInfo::shortRefs() const
|
|
|
|
|
{
|
|
|
|
|
Strings refs;
|
|
|
|
|
for (auto & r : references)
|
|
|
|
|
refs.push_back(baseNameOf(r));
|
|
|
|
|
return refs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "local-store.hh"
|
2006-11-30 19:35:36 +01:00
|
|
|
|
#include "remote-store.hh"
|
2006-11-30 18:43:04 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
|
|
2016-02-29 16:11:11 +01:00
|
|
|
|
RegisterStoreImplementation::Implementations * RegisterStoreImplementation::implementations = 0;
|
|
|
|
|
|
|
|
|
|
|
2016-04-29 16:26:16 +02:00
|
|
|
|
ref<Store> openStoreAt(const std::string & uri_)
|
2006-11-30 18:43:04 +01:00
|
|
|
|
{
|
2016-04-29 16:26:16 +02:00
|
|
|
|
auto uri(uri_);
|
|
|
|
|
StoreParams params;
|
|
|
|
|
auto q = uri.find('?');
|
|
|
|
|
if (q != std::string::npos) {
|
|
|
|
|
for (auto s : tokenizeString<Strings>(uri.substr(q + 1), "&")) {
|
|
|
|
|
auto e = s.find('=');
|
|
|
|
|
if (e != std::string::npos)
|
|
|
|
|
params[s.substr(0, e)] = s.substr(e + 1);
|
|
|
|
|
}
|
|
|
|
|
uri = uri_.substr(0, q);
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-29 16:11:11 +01:00
|
|
|
|
for (auto fun : *RegisterStoreImplementation::implementations) {
|
2016-04-29 16:26:16 +02:00
|
|
|
|
auto store = fun(uri, params);
|
2016-02-29 16:11:11 +01:00
|
|
|
|
if (store) return ref<Store>(store);
|
2016-02-24 14:48:16 +01:00
|
|
|
|
}
|
|
|
|
|
|
2016-02-29 16:11:11 +01:00
|
|
|
|
throw Error(format("don't know how to open Nix store ‘%s’") % uri);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ref<Store> openStore()
|
|
|
|
|
{
|
|
|
|
|
return openStoreAt(getEnv("NIX_REMOTE"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-29 16:26:16 +02:00
|
|
|
|
static RegisterStoreImplementation regStore([](
|
|
|
|
|
const std::string & uri, const StoreParams & params)
|
|
|
|
|
-> std::shared_ptr<Store>
|
|
|
|
|
{
|
2016-01-31 10:19:14 +01:00
|
|
|
|
enum { mDaemon, mLocal, mAuto } mode;
|
|
|
|
|
|
2016-02-29 16:11:11 +01:00
|
|
|
|
if (uri == "daemon") mode = mDaemon;
|
|
|
|
|
else if (uri == "local") mode = mLocal;
|
|
|
|
|
else if (uri == "") mode = mAuto;
|
|
|
|
|
else return 0;
|
2016-01-31 10:19:14 +01:00
|
|
|
|
|
|
|
|
|
if (mode == mAuto) {
|
|
|
|
|
if (LocalStore::haveWriteAccess())
|
|
|
|
|
mode = mLocal;
|
|
|
|
|
else if (pathExists(settings.nixDaemonSocketFile))
|
|
|
|
|
mode = mDaemon;
|
|
|
|
|
else
|
|
|
|
|
mode = mLocal;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return mode == mDaemon
|
2016-02-29 16:11:11 +01:00
|
|
|
|
? std::shared_ptr<Store>(std::make_shared<RemoteStore>())
|
|
|
|
|
: std::shared_ptr<Store>(std::make_shared<LocalStore>());
|
|
|
|
|
});
|
2016-02-24 14:48:16 +01:00
|
|
|
|
|
|
|
|
|
|
2016-04-29 13:57:08 +02:00
|
|
|
|
std::list<ref<Store>> getDefaultSubstituters()
|
|
|
|
|
{
|
|
|
|
|
struct State {
|
|
|
|
|
bool done = false;
|
|
|
|
|
std::list<ref<Store>> stores;
|
|
|
|
|
};
|
|
|
|
|
static Sync<State> state_;
|
|
|
|
|
|
|
|
|
|
auto state(state_.lock());
|
|
|
|
|
|
|
|
|
|
if (state->done) return state->stores;
|
|
|
|
|
|
|
|
|
|
StringSet done;
|
|
|
|
|
|
|
|
|
|
auto addStore = [&](const std::string & uri) {
|
|
|
|
|
if (done.count(uri)) return;
|
|
|
|
|
done.insert(uri);
|
|
|
|
|
state->stores.push_back(openStoreAt(uri));
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (auto uri : settings.get("substituters", Strings()))
|
|
|
|
|
addStore(uri);
|
|
|
|
|
|
|
|
|
|
for (auto uri : settings.get("binary-caches", Strings()))
|
|
|
|
|
addStore(uri);
|
|
|
|
|
|
|
|
|
|
for (auto uri : settings.get("extra-binary-caches", Strings()))
|
|
|
|
|
addStore(uri);
|
|
|
|
|
|
|
|
|
|
state->done = true;
|
|
|
|
|
|
|
|
|
|
return state->stores;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 18:43:04 +01:00
|
|
|
|
}
|