2016-03-24 12:41:00 +02:00
|
|
|
|
#include "crypto.hh"
|
2006-11-30 19:43:04 +02:00
|
|
|
|
#include "globals.hh"
|
2016-03-24 12:41:00 +02:00
|
|
|
|
#include "store-api.hh"
|
2006-11-30 20:35:36 +02:00
|
|
|
|
#include "util.hh"
|
2016-04-20 15:12:38 +03:00
|
|
|
|
#include "nar-info-disk-cache.hh"
|
2016-07-19 01:50:27 +03:00
|
|
|
|
#include "thread-pool.hh"
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
#include "json.hh"
|
2016-08-10 17:44:39 +03:00
|
|
|
|
#include "derivations.hh"
|
2006-11-30 19:43:04 +02:00
|
|
|
|
|
2016-09-16 19:54:14 +03:00
|
|
|
|
#include <future>
|
|
|
|
|
|
2019-07-10 20:46:15 +03:00
|
|
|
|
|
2006-11-30 19:43:04 +02:00
|
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
bool Store::isInStore(const Path & path) const
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
2016-06-01 15:49:12 +03:00
|
|
|
|
return isInDir(path, storeDir);
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
bool Store::isStorePath(const Path & path) const
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
|
|
|
|
return isInStore(path)
|
2016-06-01 15:49:12 +03:00
|
|
|
|
&& path.size() >= storeDir.size() + 1 + storePathHashLen
|
|
|
|
|
&& path.find('/', storeDir.size() + 1) == Path::npos;
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
void Store::assertStorePath(const Path & path) const
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
|
|
|
|
if (!isStorePath(path))
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw Error(format("path '%1%' is not in the Nix store") % path);
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::toStorePath(const Path & path) const
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
|
|
|
|
if (!isInStore(path))
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw Error(format("path '%1%' is not in the Nix store") % path);
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path::size_type slash = path.find('/', storeDir.size() + 1);
|
2006-11-30 19:43:04 +02:00
|
|
|
|
if (slash == Path::npos)
|
|
|
|
|
return path;
|
|
|
|
|
else
|
|
|
|
|
return Path(path, 0, slash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::followLinksToStore(const Path & _path) const
|
2007-11-29 18:18:24 +02:00
|
|
|
|
{
|
|
|
|
|
Path path = absPath(_path);
|
|
|
|
|
while (!isInStore(path)) {
|
|
|
|
|
if (!isLink(path)) break;
|
|
|
|
|
string target = readLink(path);
|
|
|
|
|
path = absPath(target, dirOf(path));
|
|
|
|
|
}
|
|
|
|
|
if (!isInStore(path))
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw Error(format("path '%1%' is not in the Nix store") % path);
|
2007-11-29 18:18:24 +02:00
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::followLinksToStorePath(const Path & path) const
|
2007-11-29 18:18:24 +02:00
|
|
|
|
{
|
|
|
|
|
return toStorePath(followLinksToStore(path));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-07-20 21:10:47 +03:00
|
|
|
|
string storePathToName(const Path & path)
|
|
|
|
|
{
|
2016-06-01 15:49:12 +03:00
|
|
|
|
auto base = baseNameOf(path);
|
|
|
|
|
assert(base.size() == storePathHashLen || (base.size() > storePathHashLen && base[storePathHashLen] == '-'));
|
|
|
|
|
return base.size() == storePathHashLen ? "" : string(base, storePathHashLen + 1);
|
2016-02-15 13:49:01 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
string storePathToHash(const Path & path)
|
|
|
|
|
{
|
2016-06-01 15:49:12 +03:00
|
|
|
|
auto base = baseNameOf(path);
|
|
|
|
|
assert(base.size() >= storePathHashLen);
|
|
|
|
|
return string(base, 0, storePathHashLen);
|
2011-07-20 21:10:47 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 19:43:04 +02:00
|
|
|
|
void checkStoreName(const string & name)
|
|
|
|
|
{
|
|
|
|
|
string validChars = "+-._?=";
|
2019-06-27 21:21:22 +03:00
|
|
|
|
|
|
|
|
|
auto baseError = format("The path name '%2%' is invalid: %3%. "
|
|
|
|
|
"Path names are alphanumeric and can include the symbols %1% "
|
|
|
|
|
"and must not begin with a period. "
|
|
|
|
|
"Note: If '%2%' is a source file and you cannot rename it on "
|
|
|
|
|
"disk, builtins.path { name = ... } can be used to give it an "
|
|
|
|
|
"alternative name.") % validChars % name;
|
|
|
|
|
|
2006-11-30 19:43:04 +02:00
|
|
|
|
/* Disallow names starting with a dot for possible security
|
|
|
|
|
reasons (e.g., "." and ".."). */
|
|
|
|
|
if (string(name, 0, 1) == ".")
|
2019-06-27 21:21:22 +03:00
|
|
|
|
throw Error(baseError % "it is illegal to start the name with a period");
|
2019-08-28 19:26:08 +03:00
|
|
|
|
/* Disallow names longer than 211 characters. ext4’s max is 256,
|
|
|
|
|
but we need extra space for the hash and .chroot extensions. */
|
|
|
|
|
if (name.length() > 211)
|
|
|
|
|
throw Error(baseError % "name must be less than 212 characters");
|
2015-07-17 20:24:28 +03: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 19:43:04 +02:00
|
|
|
|
{
|
2019-06-27 21:21:22 +03:00
|
|
|
|
throw Error(baseError % (format("the '%1%' character is invalid") % i));
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-12-03 17:06:30 +02:00
|
|
|
|
/* Store paths have the following form:
|
|
|
|
|
|
|
|
|
|
<store>/<h>-<name>
|
|
|
|
|
|
|
|
|
|
where
|
|
|
|
|
|
|
|
|
|
<store> = the location of the Nix store, usually /nix/store
|
2015-07-17 20:24:28 +03:00
|
|
|
|
|
2008-12-03 17:06:30 +02: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 21:10:47 +03: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 20:24:28 +03:00
|
|
|
|
|
2008-12-03 17:06:30 +02: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 20:24:28 +03:00
|
|
|
|
|
2008-12-03 17:06:30 +02: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 20:24:28 +03:00
|
|
|
|
|
2008-12-03 17:06:30 +02: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 21:10:47 +03:00
|
|
|
|
"output:<id>"
|
2008-12-03 17:06:30 +02: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 21:10:47 +03:00
|
|
|
|
silly, but it's done that way for compatibility). <id> is the
|
|
|
|
|
name of the output (usually, "out").
|
2008-12-03 17:06:30 +02: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 12:27:58 +02:00
|
|
|
|
if <type> = "output:<id>":
|
2008-12-03 17:06:30 +02: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 12:27:58 +02:00
|
|
|
|
<rec> = "r:" for recursive (path) hashes, or "" for flat
|
2008-12-03 17:06:30 +02: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
|
2017-05-11 15:02:03 +03:00
|
|
|
|
"output:out:", while the latter would have a <s> starting with
|
2008-12-03 17:06:30 +02:00
|
|
|
|
"source:".
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::makeStorePath(const string & type,
|
|
|
|
|
const Hash & hash, const string & name) const
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
|
|
|
|
/* e.g., "source:sha256:1abc...:/nix/store:foo.tar.gz" */
|
2017-07-04 15:47:59 +03:00
|
|
|
|
string s = type + ":" + hash.to_string(Base16) + ":" + storeDir + ":" + name;
|
2006-11-30 19:43:04 +02:00
|
|
|
|
|
2008-12-03 17:06:30 +02:00
|
|
|
|
checkStoreName(name);
|
2006-11-30 19:43:04 +02:00
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
return storeDir + "/"
|
2017-07-04 15:47:59 +03:00
|
|
|
|
+ compressHash(hashString(htSHA256, s), 20).to_string(Base32, false)
|
2008-12-03 17:06:30 +02:00
|
|
|
|
+ "-" + name;
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::makeOutputPath(const string & id,
|
|
|
|
|
const Hash & hash, const string & name) const
|
2011-07-20 21:10:47 +03:00
|
|
|
|
{
|
|
|
|
|
return makeStorePath("output:" + id, hash,
|
|
|
|
|
name + (id == "out" ? "" : "-" + id));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-03-30 01:56:13 +03:00
|
|
|
|
static std::string makeType(string && type, const PathSet & references)
|
|
|
|
|
{
|
|
|
|
|
for (auto & i : references) {
|
|
|
|
|
type += ":";
|
|
|
|
|
type += i;
|
|
|
|
|
}
|
|
|
|
|
return type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::makeFixedOutputPath(bool recursive,
|
2018-03-30 01:56:13 +03:00
|
|
|
|
const Hash & hash, const string & name, const PathSet & references) const
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
2018-03-30 01:56:13 +03:00
|
|
|
|
if (hash.type == htSHA256 && recursive) {
|
|
|
|
|
return makeStorePath(makeType("source", references), hash, name);
|
|
|
|
|
} else {
|
|
|
|
|
assert(references.empty());
|
|
|
|
|
return makeStorePath("output:out", hashString(htSHA256,
|
2008-12-03 18:10:17 +02:00
|
|
|
|
"fixed:out:" + (recursive ? (string) "r:" : "") +
|
2018-03-30 01:56:13 +03:00
|
|
|
|
hash.to_string(Base16) + ":"), name);
|
|
|
|
|
}
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2006-12-01 20:00:01 +02:00
|
|
|
|
|
2016-08-03 14:17:11 +03:00
|
|
|
|
Path Store::makeTextPath(const string & name, const Hash & hash,
|
|
|
|
|
const PathSet & references) const
|
|
|
|
|
{
|
|
|
|
|
assert(hash.type == htSHA256);
|
|
|
|
|
/* 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. */
|
2018-03-30 01:56:13 +03:00
|
|
|
|
return makeStorePath(makeType("text", references), hash, name);
|
2016-08-03 14:17:11 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-01-25 17:05:57 +02:00
|
|
|
|
std::pair<Path, Hash> Store::computeStorePathForPath(const string & name,
|
|
|
|
|
const Path & srcPath, bool recursive, HashType hashAlgo, PathFilter & filter) const
|
2006-12-01 20:00:01 +02:00
|
|
|
|
{
|
2016-07-26 22:25:52 +03:00
|
|
|
|
Hash h = recursive ? hashPath(hashAlgo, srcPath, filter).first : hashFile(hashAlgo, srcPath);
|
|
|
|
|
Path dstPath = makeFixedOutputPath(recursive, h, name);
|
2006-12-01 20:00:01 +02:00
|
|
|
|
return std::pair<Path, Hash>(dstPath, h);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Path Store::computeStorePathForText(const string & name, const string & s,
|
|
|
|
|
const PathSet & references) const
|
2006-12-01 20:00:01 +02:00
|
|
|
|
{
|
2016-08-03 14:17:11 +03:00
|
|
|
|
return makeTextPath(name, hashString(htSHA256, s), references);
|
2006-12-01 20:00:01 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-06-01 15:49:12 +03:00
|
|
|
|
Store::Store(const Params & params)
|
2017-04-13 16:55:38 +03:00
|
|
|
|
: Config(params)
|
|
|
|
|
, state({(size_t) pathInfoCacheSize})
|
2016-06-01 15:49:12 +03:00
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-20 15:12:38 +03:00
|
|
|
|
std::string Store::getUri()
|
|
|
|
|
{
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
bool Store::isValidPath(const Path & storePath)
|
2016-02-15 15:48:38 +02:00
|
|
|
|
{
|
2018-03-27 17:12:00 +03:00
|
|
|
|
assertStorePath(storePath);
|
|
|
|
|
|
2016-04-21 18:53:47 +03:00
|
|
|
|
auto hashPart = storePathToHash(storePath);
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
2016-04-21 18:53:47 +03:00
|
|
|
|
auto res = state_->pathInfoCache.get(hashPart);
|
2016-04-19 19:50:15 +03:00
|
|
|
|
if (res) {
|
|
|
|
|
stats.narInfoReadAverted++;
|
|
|
|
|
return *res != 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-20 15:12:38 +03:00
|
|
|
|
if (diskCache) {
|
2016-04-21 18:53:47 +03:00
|
|
|
|
auto res = diskCache->lookupNarInfo(getUri(), hashPart);
|
2016-04-20 15:12:38 +03:00
|
|
|
|
if (res.first != NarInfoDiskCache::oUnknown) {
|
2016-04-21 18:53:47 +03:00
|
|
|
|
stats.narInfoReadAverted++;
|
2016-04-20 15:12:38 +03:00
|
|
|
|
auto state_(state.lock());
|
2016-04-21 18:53:47 +03:00
|
|
|
|
state_->pathInfoCache.upsert(hashPart,
|
2016-04-20 15:12:38 +03:00
|
|
|
|
res.first == NarInfoDiskCache::oInvalid ? 0 : res.second);
|
|
|
|
|
return res.first == NarInfoDiskCache::oValid;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-20 18:39:05 +03:00
|
|
|
|
bool valid = isValidPathUncached(storePath);
|
2016-04-20 15:12:38 +03:00
|
|
|
|
|
2016-06-20 18:39:05 +03:00
|
|
|
|
if (diskCache && !valid)
|
|
|
|
|
// FIXME: handle valid = true case.
|
|
|
|
|
diskCache->upsertNarInfo(getUri(), hashPart, 0);
|
|
|
|
|
|
|
|
|
|
return valid;
|
2016-04-19 19:50:15 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-02-07 20:22:48 +02:00
|
|
|
|
/* Default implementation for stores that only implement
|
|
|
|
|
queryPathInfoUncached(). */
|
|
|
|
|
bool Store::isValidPathUncached(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
try {
|
|
|
|
|
queryPathInfo(path);
|
|
|
|
|
return true;
|
|
|
|
|
} catch (InvalidPath &) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
ref<const ValidPathInfo> Store::queryPathInfo(const Path & storePath)
|
2016-09-16 19:54:14 +03:00
|
|
|
|
{
|
|
|
|
|
std::promise<ref<ValidPathInfo>> promise;
|
|
|
|
|
|
|
|
|
|
queryPathInfo(storePath,
|
2018-03-27 23:16:01 +03:00
|
|
|
|
{[&](std::future<ref<ValidPathInfo>> result) {
|
|
|
|
|
try {
|
|
|
|
|
promise.set_value(result.get());
|
|
|
|
|
} catch (...) {
|
|
|
|
|
promise.set_exception(std::current_exception());
|
|
|
|
|
}
|
|
|
|
|
}});
|
2016-09-16 19:54:14 +03:00
|
|
|
|
|
|
|
|
|
return promise.get_future().get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void Store::queryPathInfo(const Path & storePath,
|
2019-09-03 14:00:55 +03:00
|
|
|
|
Callback<ref<ValidPathInfo>> callback) noexcept
|
2016-04-19 19:50:15 +03:00
|
|
|
|
{
|
2019-09-03 14:00:55 +03:00
|
|
|
|
std::string hashPart;
|
2016-04-21 18:53:47 +03:00
|
|
|
|
|
2016-09-16 19:54:14 +03:00
|
|
|
|
try {
|
2019-09-03 14:00:55 +03:00
|
|
|
|
assertStorePath(storePath);
|
|
|
|
|
|
|
|
|
|
hashPart = storePathToHash(storePath);
|
2016-09-16 19:54:14 +03:00
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
auto res = state.lock()->pathInfoCache.get(hashPart);
|
|
|
|
|
if (res) {
|
|
|
|
|
stats.narInfoReadAverted++;
|
|
|
|
|
if (!*res)
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw InvalidPath(format("path '%s' is not valid") % storePath);
|
2018-03-27 23:16:01 +03:00
|
|
|
|
return callback(ref<ValidPathInfo>(*res));
|
2016-09-16 19:54:14 +03:00
|
|
|
|
}
|
2016-04-19 19:50:15 +03:00
|
|
|
|
}
|
|
|
|
|
|
2016-09-16 19:54:14 +03:00
|
|
|
|
if (diskCache) {
|
|
|
|
|
auto res = diskCache->lookupNarInfo(getUri(), hashPart);
|
|
|
|
|
if (res.first != NarInfoDiskCache::oUnknown) {
|
|
|
|
|
stats.narInfoReadAverted++;
|
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
|
|
|
|
state_->pathInfoCache.upsert(hashPart,
|
|
|
|
|
res.first == NarInfoDiskCache::oInvalid ? 0 : res.second);
|
|
|
|
|
if (res.first == NarInfoDiskCache::oInvalid ||
|
|
|
|
|
(res.second->path != storePath && storePathToName(storePath) != ""))
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw InvalidPath(format("path '%s' is not valid") % storePath);
|
2016-09-16 19:54:14 +03:00
|
|
|
|
}
|
2018-03-27 23:16:01 +03:00
|
|
|
|
return callback(ref<ValidPathInfo>(res.second));
|
2016-09-16 19:54:14 +03:00
|
|
|
|
}
|
2016-04-20 15:12:38 +03:00
|
|
|
|
}
|
2016-09-16 19:54:14 +03:00
|
|
|
|
|
2018-03-27 23:16:01 +03:00
|
|
|
|
} catch (...) { return callback.rethrow(); }
|
2016-04-20 15:12:38 +03:00
|
|
|
|
|
2019-09-03 13:51:35 +03:00
|
|
|
|
auto callbackPtr = std::make_shared<decltype(callback)>(std::move(callback));
|
|
|
|
|
|
2016-09-16 19:54:14 +03:00
|
|
|
|
queryPathInfoUncached(storePath,
|
2019-09-03 13:51:35 +03:00
|
|
|
|
{[this, storePath, hashPart, callbackPtr](std::future<std::shared_ptr<ValidPathInfo>> fut) {
|
2016-04-19 19:50:15 +03:00
|
|
|
|
|
2018-03-27 23:16:01 +03:00
|
|
|
|
try {
|
|
|
|
|
auto info = fut.get();
|
2016-04-20 15:12:38 +03:00
|
|
|
|
|
2018-03-27 23:16:01 +03:00
|
|
|
|
if (diskCache)
|
|
|
|
|
diskCache->upsertNarInfo(getUri(), hashPart, info);
|
2016-04-19 19:50:15 +03:00
|
|
|
|
|
2018-03-27 23:16:01 +03:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
|
|
|
|
state_->pathInfoCache.upsert(hashPart, info);
|
|
|
|
|
}
|
2016-09-16 19:54:14 +03:00
|
|
|
|
|
2018-03-27 23:16:01 +03:00
|
|
|
|
if (!info
|
|
|
|
|
|| (info->path != storePath && storePathToName(storePath) != ""))
|
|
|
|
|
{
|
|
|
|
|
stats.narInfoMissing++;
|
|
|
|
|
throw InvalidPath("path '%s' is not valid", storePath);
|
|
|
|
|
}
|
2016-04-19 19:50:15 +03:00
|
|
|
|
|
2019-09-03 13:51:35 +03:00
|
|
|
|
(*callbackPtr)(ref<ValidPathInfo>(info));
|
|
|
|
|
} catch (...) { callbackPtr->rethrow(); }
|
2018-03-27 23:16:01 +03:00
|
|
|
|
}});
|
2016-02-15 15:48:38 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
PathSet Store::queryValidPaths(const PathSet & paths, SubstituteFlag maybeSubstitute)
|
2016-10-07 20:20:47 +03:00
|
|
|
|
{
|
2016-10-07 20:43:36 +03:00
|
|
|
|
struct State
|
|
|
|
|
{
|
|
|
|
|
size_t left;
|
|
|
|
|
PathSet valid;
|
|
|
|
|
std::exception_ptr exc;
|
|
|
|
|
};
|
2016-10-07 20:20:47 +03:00
|
|
|
|
|
2016-10-07 20:43:36 +03:00
|
|
|
|
Sync<State> state_(State{paths.size(), PathSet()});
|
2016-10-07 20:20:47 +03:00
|
|
|
|
|
2016-10-07 20:43:36 +03:00
|
|
|
|
std::condition_variable wakeup;
|
2017-10-25 18:13:49 +03:00
|
|
|
|
ThreadPool pool;
|
2016-10-07 20:43:36 +03:00
|
|
|
|
|
2017-10-25 18:13:49 +03:00
|
|
|
|
auto doQuery = [&](const Path & path ) {
|
2017-10-25 18:51:45 +03:00
|
|
|
|
checkInterrupt();
|
2018-03-27 23:16:01 +03:00
|
|
|
|
queryPathInfo(path, {[path, &state_, &wakeup](std::future<ref<ValidPathInfo>> fut) {
|
|
|
|
|
auto state(state_.lock());
|
|
|
|
|
try {
|
|
|
|
|
auto info = fut.get();
|
2016-10-07 20:43:36 +03:00
|
|
|
|
state->valid.insert(path);
|
2018-03-27 23:16:01 +03:00
|
|
|
|
} catch (InvalidPath &) {
|
|
|
|
|
} catch (...) {
|
|
|
|
|
state->exc = std::current_exception();
|
|
|
|
|
}
|
|
|
|
|
assert(state->left);
|
|
|
|
|
if (!--state->left)
|
|
|
|
|
wakeup.notify_one();
|
|
|
|
|
}});
|
2017-10-25 18:13:49 +03:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (auto & path : paths)
|
|
|
|
|
pool.enqueue(std::bind(doQuery, path));
|
|
|
|
|
|
|
|
|
|
pool.process();
|
2016-10-07 20:43:36 +03:00
|
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
|
auto state(state_.lock());
|
|
|
|
|
if (!state->left) {
|
|
|
|
|
if (state->exc) std::rethrow_exception(state->exc);
|
|
|
|
|
return state->valid;
|
|
|
|
|
}
|
|
|
|
|
state.wait(wakeup);
|
|
|
|
|
}
|
2016-10-07 20:20:47 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-01-29 20:17:36 +02: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 15:48:42 +02:00
|
|
|
|
string Store::makeValidityRegistration(const PathSet & paths,
|
2008-01-29 20:17:36 +02:00
|
|
|
|
bool showDerivers, bool showHash)
|
|
|
|
|
{
|
|
|
|
|
string s = "";
|
|
|
|
|
|
2015-07-17 20:24:28 +03:00
|
|
|
|
for (auto & i : paths) {
|
|
|
|
|
s += i + "\n";
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
auto info = queryPathInfo(i);
|
2008-01-29 20:17:36 +02:00
|
|
|
|
|
2010-11-16 19:11:46 +02:00
|
|
|
|
if (showHash) {
|
2017-07-04 15:47:59 +03:00
|
|
|
|
s += info->narHash.to_string(Base16, false) + "\n";
|
2016-04-19 19:50:15 +03:00
|
|
|
|
s += (format("%1%\n") % info->narSize).str();
|
2010-11-16 19:11:46 +02:00
|
|
|
|
}
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
Path deriver = showDerivers ? info->deriver : "";
|
2008-01-29 20:17:36 +02:00
|
|
|
|
s += deriver + "\n";
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
s += (format("%1%\n") % info->references.size()).str();
|
2008-01-29 20:17:36 +02:00
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
for (auto & j : info->references)
|
2015-07-17 20:24:28 +03:00
|
|
|
|
s += j + "\n";
|
2008-01-29 20:17:36 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
void Store::pathInfoToJSON(JSONPlaceholder & jsonOut, const PathSet & storePaths,
|
2017-07-14 16:27:21 +03:00
|
|
|
|
bool includeImpureInfo, bool showClosureSize, AllowInvalidFlag allowInvalid)
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
{
|
|
|
|
|
auto jsonList = jsonOut.list();
|
|
|
|
|
|
|
|
|
|
for (auto storePath : storePaths) {
|
|
|
|
|
auto jsonPath = jsonList.object();
|
2017-07-14 16:27:21 +03:00
|
|
|
|
jsonPath.attr("path", storePath);
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
try {
|
|
|
|
|
auto info = queryPathInfo(storePath);
|
|
|
|
|
storePath = info->path;
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
jsonPath
|
|
|
|
|
.attr("narHash", info->narHash.to_string())
|
|
|
|
|
.attr("narSize", info->narSize);
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
{
|
|
|
|
|
auto jsonRefs = jsonPath.list("references");
|
|
|
|
|
for (auto & ref : info->references)
|
|
|
|
|
jsonRefs.elem(ref);
|
|
|
|
|
}
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
if (info->ca != "")
|
|
|
|
|
jsonPath.attr("ca", info->ca);
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 18:36:49 +03:00
|
|
|
|
std::pair<uint64_t, uint64_t> closureSizes;
|
|
|
|
|
|
|
|
|
|
if (showClosureSize) {
|
|
|
|
|
closureSizes = getClosureSize(storePath);
|
|
|
|
|
jsonPath.attr("closureSize", closureSizes.first);
|
|
|
|
|
}
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
if (includeImpureInfo) {
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
if (info->deriver != "")
|
|
|
|
|
jsonPath.attr("deriver", info->deriver);
|
|
|
|
|
|
|
|
|
|
if (info->registrationTime)
|
|
|
|
|
jsonPath.attr("registrationTime", info->registrationTime);
|
|
|
|
|
|
|
|
|
|
if (info->ultimate)
|
|
|
|
|
jsonPath.attr("ultimate", info->ultimate);
|
|
|
|
|
|
|
|
|
|
if (!info->sigs.empty()) {
|
|
|
|
|
auto jsonSigs = jsonPath.list("signatures");
|
|
|
|
|
for (auto & sig : info->sigs)
|
|
|
|
|
jsonSigs.elem(sig);
|
|
|
|
|
}
|
2017-05-08 14:36:23 +03:00
|
|
|
|
|
2017-07-14 18:36:49 +03:00
|
|
|
|
auto narInfo = std::dynamic_pointer_cast<const NarInfo>(
|
|
|
|
|
std::shared_ptr<const ValidPathInfo>(info));
|
|
|
|
|
|
|
|
|
|
if (narInfo) {
|
2017-11-24 19:08:50 +02:00
|
|
|
|
if (!narInfo->url.empty())
|
|
|
|
|
jsonPath.attr("url", narInfo->url);
|
2017-07-14 18:36:49 +03:00
|
|
|
|
if (narInfo->fileHash)
|
|
|
|
|
jsonPath.attr("downloadHash", narInfo->fileHash.to_string());
|
|
|
|
|
if (narInfo->fileSize)
|
|
|
|
|
jsonPath.attr("downloadSize", narInfo->fileSize);
|
|
|
|
|
if (showClosureSize)
|
|
|
|
|
jsonPath.attr("closureDownloadSize", closureSizes.second);
|
|
|
|
|
}
|
2017-05-08 14:36:23 +03:00
|
|
|
|
}
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
|
2017-07-14 16:27:21 +03:00
|
|
|
|
} catch (InvalidPath &) {
|
|
|
|
|
jsonPath.attr("valid", false);
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-07-14 18:36:49 +03:00
|
|
|
|
std::pair<uint64_t, uint64_t> Store::getClosureSize(const Path & storePath)
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
{
|
2017-07-14 18:36:49 +03:00
|
|
|
|
uint64_t totalNarSize = 0, totalDownloadSize = 0;
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
PathSet closure;
|
|
|
|
|
computeFSClosure(storePath, closure, false, false);
|
2017-07-14 18:36:49 +03:00
|
|
|
|
for (auto & p : closure) {
|
|
|
|
|
auto info = queryPathInfo(p);
|
|
|
|
|
totalNarSize += info->narSize;
|
|
|
|
|
auto narInfo = std::dynamic_pointer_cast<const NarInfo>(
|
|
|
|
|
std::shared_ptr<const ValidPathInfo>(info));
|
|
|
|
|
if (narInfo)
|
|
|
|
|
totalDownloadSize += narInfo->fileSize;
|
|
|
|
|
}
|
|
|
|
|
return {totalNarSize, totalDownloadSize};
|
exportReferencesGraph: Export more complete info in JSON format
This writes info about every path in the closure in the same format as
‘nix path-info --json’. Thus it also includes NAR hashes and sizes.
Example:
[
{
"path": "/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"narHash": "sha256:0ckdc4z20kkmpqdilx0wl6cricxv90lh85xpv2qljppcmz6vzcxl",
"narSize": 197648,
"references": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20939776
},
{
"path": "/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24",
"narHash": "sha256:1nfn3m3p98y1c0kd0brp80dn9n5mycwgrk183j17rajya0h7gax3",
"narSize": 20742128,
"references": [
"/nix/store/27binbdy296qvjycdgr1535v8872vz3z-glibc-2.24"
],
"closureSize": 20742128
}
]
Fixes #1134.
2017-01-26 21:36:20 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-19 19:50:15 +03:00
|
|
|
|
const Store::Stats & Store::getStats()
|
|
|
|
|
{
|
2016-04-20 15:12:38 +03:00
|
|
|
|
{
|
|
|
|
|
auto state_(state.lock());
|
|
|
|
|
stats.pathInfoCacheSize = state_->pathInfoCache.size();
|
|
|
|
|
}
|
2016-04-19 19:50:15 +03:00
|
|
|
|
return stats;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-05-01 14:43:34 +03:00
|
|
|
|
void Store::buildPaths(const PathSet & paths, BuildMode buildMode)
|
|
|
|
|
{
|
|
|
|
|
for (auto & path : paths)
|
|
|
|
|
if (isDerivation(path))
|
2019-01-18 14:34:23 +02:00
|
|
|
|
unsupported("buildPaths");
|
2017-05-01 14:43:34 +03:00
|
|
|
|
|
|
|
|
|
if (queryValidPaths(paths).size() != paths.size())
|
2019-01-18 14:34:23 +02:00
|
|
|
|
unsupported("buildPaths");
|
2017-05-01 14:43:34 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-05-03 15:45:50 +03:00
|
|
|
|
void copyStorePath(ref<Store> srcStore, ref<Store> dstStore,
|
2017-06-28 19:11:01 +03:00
|
|
|
|
const Path & storePath, RepairFlag repair, CheckSigsFlag checkSigs)
|
2016-05-03 15:45:50 +03:00
|
|
|
|
{
|
2019-07-10 20:46:15 +03:00
|
|
|
|
auto srcUri = srcStore->getUri();
|
|
|
|
|
auto dstUri = dstStore->getUri();
|
|
|
|
|
|
|
|
|
|
Activity act(*logger, lvlInfo, actCopyPath,
|
|
|
|
|
srcUri == "local" || srcUri == "daemon"
|
|
|
|
|
? fmt("copying path '%s' to '%s'", storePath, dstUri)
|
|
|
|
|
: dstUri == "local" || dstUri == "daemon"
|
|
|
|
|
? fmt("copying path '%s' from '%s'", storePath, srcUri)
|
|
|
|
|
: fmt("copying path '%s' from '%s' to '%s'", storePath, srcUri, dstUri),
|
|
|
|
|
{storePath, srcUri, dstUri});
|
|
|
|
|
PushActivity pact(act.id);
|
|
|
|
|
|
|
|
|
|
auto info = srcStore->queryPathInfo(storePath);
|
|
|
|
|
|
|
|
|
|
uint64_t total = 0;
|
|
|
|
|
|
|
|
|
|
if (!info->narHash) {
|
|
|
|
|
StringSink sink;
|
|
|
|
|
srcStore->narFromPath({storePath}, sink);
|
|
|
|
|
auto info2 = make_ref<ValidPathInfo>(*info);
|
|
|
|
|
info2->narHash = hashString(htSHA256, *sink.s);
|
|
|
|
|
if (!info->narSize) info2->narSize = sink.s->size();
|
|
|
|
|
if (info->ultimate) info2->ultimate = false;
|
|
|
|
|
info = info2;
|
|
|
|
|
|
|
|
|
|
StringSource source(*sink.s);
|
|
|
|
|
dstStore->addToStore(*info, source, repair, checkSigs);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2017-02-07 20:23:16 +02:00
|
|
|
|
|
2019-07-10 20:46:15 +03:00
|
|
|
|
if (info->ultimate) {
|
|
|
|
|
auto info2 = make_ref<ValidPathInfo>(*info);
|
|
|
|
|
info2->ultimate = false;
|
|
|
|
|
info = info2;
|
|
|
|
|
}
|
2017-05-01 21:03:25 +03:00
|
|
|
|
|
2019-07-10 20:46:15 +03:00
|
|
|
|
auto source = sinkToSource([&](Sink & sink) {
|
|
|
|
|
LambdaSink wrapperSink([&](const unsigned char * data, size_t len) {
|
|
|
|
|
sink(data, len);
|
|
|
|
|
total += len;
|
|
|
|
|
act.progress(total, info->narSize);
|
2018-03-16 21:22:34 +02:00
|
|
|
|
});
|
2019-07-10 20:46:15 +03:00
|
|
|
|
srcStore->narFromPath({storePath}, wrapperSink);
|
|
|
|
|
}, [&]() {
|
|
|
|
|
throw EndOfFile("NAR for '%s' fetched from '%s' is incomplete", storePath, srcStore->getUri());
|
2019-06-24 22:48:52 +03:00
|
|
|
|
});
|
2019-07-10 20:46:15 +03:00
|
|
|
|
|
|
|
|
|
dstStore->addToStore(*info, *source, repair, checkSigs);
|
2016-05-03 15:45:50 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
void copyPaths(ref<Store> srcStore, ref<Store> dstStore, const PathSet & storePaths,
|
|
|
|
|
RepairFlag repair, CheckSigsFlag checkSigs, SubstituteFlag substitute)
|
2016-10-07 20:15:25 +03:00
|
|
|
|
{
|
2017-06-28 19:11:01 +03:00
|
|
|
|
PathSet valid = dstStore->queryValidPaths(storePaths, substitute);
|
|
|
|
|
|
|
|
|
|
PathSet missing;
|
2016-10-07 20:15:25 +03:00
|
|
|
|
for (auto & path : storePaths)
|
2017-06-28 19:11:01 +03:00
|
|
|
|
if (!valid.count(path)) missing.insert(path);
|
2016-10-07 20:15:25 +03:00
|
|
|
|
|
2017-10-18 16:02:58 +03:00
|
|
|
|
if (missing.empty()) return;
|
|
|
|
|
|
2017-08-28 20:13:24 +03:00
|
|
|
|
Activity act(*logger, lvlInfo, actCopyPaths, fmt("copying %d paths", missing.size()));
|
2017-08-14 16:28:16 +03:00
|
|
|
|
|
2017-08-14 23:12:36 +03:00
|
|
|
|
std::atomic<size_t> nrDone{0};
|
2018-07-24 18:03:54 +03:00
|
|
|
|
std::atomic<size_t> nrFailed{0};
|
2017-08-14 20:00:03 +03:00
|
|
|
|
std::atomic<uint64_t> bytesExpected{0};
|
2017-08-14 23:42:17 +03:00
|
|
|
|
std::atomic<uint64_t> nrRunning{0};
|
2017-08-14 16:28:16 +03:00
|
|
|
|
|
|
|
|
|
auto showProgress = [&]() {
|
2018-07-24 18:03:54 +03:00
|
|
|
|
act.progress(nrDone, missing.size(), nrRunning, nrFailed);
|
2017-08-14 16:28:16 +03:00
|
|
|
|
};
|
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
ThreadPool pool;
|
2017-03-16 14:50:01 +02:00
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
processGraph<Path>(pool,
|
|
|
|
|
PathSet(missing.begin(), missing.end()),
|
2016-10-07 20:15:25 +03:00
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
[&](const Path & storePath) {
|
2017-08-14 16:28:16 +03:00
|
|
|
|
if (dstStore->isValidPath(storePath)) {
|
|
|
|
|
nrDone++;
|
|
|
|
|
showProgress();
|
|
|
|
|
return PathSet();
|
|
|
|
|
}
|
2017-08-14 20:00:03 +03:00
|
|
|
|
|
|
|
|
|
auto info = srcStore->queryPathInfo(storePath);
|
|
|
|
|
|
|
|
|
|
bytesExpected += info->narSize;
|
2017-08-16 17:38:23 +03:00
|
|
|
|
act.setExpected(actCopyPath, bytesExpected);
|
2017-08-14 20:00:03 +03:00
|
|
|
|
|
|
|
|
|
return info->references;
|
2017-06-28 19:11:01 +03:00
|
|
|
|
},
|
2016-10-07 20:15:25 +03:00
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
[&](const Path & storePath) {
|
|
|
|
|
checkInterrupt();
|
2016-10-07 20:15:25 +03:00
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
if (!dstStore->isValidPath(storePath)) {
|
2017-08-14 23:42:17 +03:00
|
|
|
|
MaintainCount<decltype(nrRunning)> mc(nrRunning);
|
|
|
|
|
showProgress();
|
2018-07-24 18:03:54 +03:00
|
|
|
|
try {
|
|
|
|
|
copyStorePath(srcStore, dstStore, storePath, repair, checkSigs);
|
|
|
|
|
} catch (Error &e) {
|
|
|
|
|
nrFailed++;
|
|
|
|
|
if (!settings.keepGoing)
|
|
|
|
|
throw e;
|
|
|
|
|
logger->log(lvlError, format("could not copy %s: %s") % storePath % e.what());
|
|
|
|
|
showProgress();
|
|
|
|
|
return;
|
|
|
|
|
}
|
2017-06-28 19:11:01 +03:00
|
|
|
|
}
|
2017-08-14 16:28:16 +03:00
|
|
|
|
|
|
|
|
|
nrDone++;
|
|
|
|
|
showProgress();
|
2017-06-28 19:11:01 +03:00
|
|
|
|
});
|
|
|
|
|
}
|
2016-10-07 20:15:25 +03:00
|
|
|
|
|
|
|
|
|
|
2017-06-28 19:11:01 +03:00
|
|
|
|
void copyClosure(ref<Store> srcStore, ref<Store> dstStore,
|
|
|
|
|
const PathSet & storePaths, RepairFlag repair, CheckSigsFlag checkSigs,
|
|
|
|
|
SubstituteFlag substitute)
|
|
|
|
|
{
|
|
|
|
|
PathSet closure;
|
|
|
|
|
srcStore->computeFSClosure({storePaths}, closure);
|
|
|
|
|
copyPaths(srcStore, dstStore, closure, repair, checkSigs, substitute);
|
2016-10-07 20:15:25 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-01-29 20:17:36 +02:00
|
|
|
|
ValidPathInfo decodeValidPathInfo(std::istream & str, bool hashGiven)
|
2007-08-12 03:29:28 +03:00
|
|
|
|
{
|
|
|
|
|
ValidPathInfo info;
|
|
|
|
|
getline(str, info.path);
|
|
|
|
|
if (str.eof()) { info.path = ""; return info; }
|
2008-01-29 20:17:36 +02:00
|
|
|
|
if (hashGiven) {
|
|
|
|
|
string s;
|
|
|
|
|
getline(str, s);
|
2017-07-04 15:47:59 +03:00
|
|
|
|
info.narHash = Hash(s, htSHA256);
|
2010-11-16 19:11:46 +02:00
|
|
|
|
getline(str, s);
|
|
|
|
|
if (!string2Int(s, info.narSize)) throw Error("number expected");
|
2008-01-29 20:17:36 +02:00
|
|
|
|
}
|
2007-08-12 03:29:28 +03: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 16:52:45 +03:00
|
|
|
|
string showPaths(const PathSet & paths)
|
|
|
|
|
{
|
|
|
|
|
string s;
|
2015-07-17 20:24:28 +03:00
|
|
|
|
for (auto & i : paths) {
|
2008-06-09 16:52:45 +03:00
|
|
|
|
if (s.size() != 0) s += ", ";
|
2017-07-30 14:27:57 +03:00
|
|
|
|
s += "'" + i + "'";
|
2008-06-09 16:52:45 +03:00
|
|
|
|
}
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-03-24 12:41:00 +02:00
|
|
|
|
std::string ValidPathInfo::fingerprint() const
|
|
|
|
|
{
|
2016-04-20 15:12:38 +03:00
|
|
|
|
if (narSize == 0 || !narHash)
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw Error(format("cannot calculate fingerprint of path '%s' because its size/hash is not known")
|
2016-04-05 17:39:29 +03:00
|
|
|
|
% path);
|
2016-03-24 12:41:00 +02:00
|
|
|
|
return
|
|
|
|
|
"1;" + path + ";"
|
2017-07-04 15:47:59 +03:00
|
|
|
|
+ narHash.to_string(Base32) + ";"
|
2016-03-24 12:41:00 +02:00
|
|
|
|
+ std::to_string(narSize) + ";"
|
|
|
|
|
+ concatStringsSep(",", references);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ValidPathInfo::sign(const SecretKey & secretKey)
|
|
|
|
|
{
|
|
|
|
|
sigs.insert(secretKey.signDetached(fingerprint()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-08-03 14:17:11 +03:00
|
|
|
|
bool ValidPathInfo::isContentAddressed(const Store & store) const
|
|
|
|
|
{
|
|
|
|
|
auto warn = [&]() {
|
2017-07-30 14:27:57 +03:00
|
|
|
|
printError(format("warning: path '%s' claims to be content-addressed but isn't") % path);
|
2016-08-03 14:17:11 +03:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (hasPrefix(ca, "text:")) {
|
2017-07-04 15:47:59 +03:00
|
|
|
|
Hash hash(std::string(ca, 5));
|
2016-08-03 14:17:11 +03:00
|
|
|
|
if (store.makeTextPath(storePathToName(path), hash, references) == path)
|
|
|
|
|
return true;
|
|
|
|
|
else
|
|
|
|
|
warn();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else if (hasPrefix(ca, "fixed:")) {
|
|
|
|
|
bool recursive = ca.compare(6, 2, "r:") == 0;
|
2017-07-04 15:47:59 +03:00
|
|
|
|
Hash hash(std::string(ca, recursive ? 8 : 6));
|
2018-03-30 01:56:13 +03:00
|
|
|
|
auto refs = references;
|
|
|
|
|
replaceInSet(refs, path, std::string("self"));
|
|
|
|
|
if (store.makeFixedOutputPath(recursive, hash, storePathToName(path), refs) == path)
|
2016-08-03 14:17:11 +03:00
|
|
|
|
return true;
|
|
|
|
|
else
|
|
|
|
|
warn();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
size_t ValidPathInfo::checkSignatures(const Store & store, const PublicKeys & publicKeys) const
|
2016-03-24 12:41:00 +02:00
|
|
|
|
{
|
2016-08-03 14:17:11 +03:00
|
|
|
|
if (isContentAddressed(store)) return maxSigs;
|
|
|
|
|
|
|
|
|
|
size_t good = 0;
|
2016-03-24 12:41:00 +02:00
|
|
|
|
for (auto & sig : sigs)
|
2016-04-07 16:14:12 +03:00
|
|
|
|
if (checkSignature(publicKeys, sig))
|
2016-03-24 12:41:00 +02:00
|
|
|
|
good++;
|
|
|
|
|
return good;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-07 16:14:12 +03:00
|
|
|
|
bool ValidPathInfo::checkSignature(const PublicKeys & publicKeys, const std::string & sig) const
|
|
|
|
|
{
|
|
|
|
|
return verifyDetached(fingerprint(), sig, publicKeys);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-20 15:12:38 +03:00
|
|
|
|
Strings ValidPathInfo::shortRefs() const
|
|
|
|
|
{
|
|
|
|
|
Strings refs;
|
|
|
|
|
for (auto & r : references)
|
|
|
|
|
refs.push_back(baseNameOf(r));
|
|
|
|
|
return refs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-02-22 17:31:04 +02:00
|
|
|
|
std::string makeFixedOutputCA(bool recursive, const Hash & hash)
|
|
|
|
|
{
|
|
|
|
|
return "fixed:" + (recursive ? (std::string) "r:" : "") + hash.to_string();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-03-16 21:22:34 +02:00
|
|
|
|
void Store::addToStore(const ValidPathInfo & info, Source & narSource,
|
|
|
|
|
RepairFlag repair, CheckSigsFlag checkSigs,
|
|
|
|
|
std::shared_ptr<FSAccessor> accessor)
|
|
|
|
|
{
|
|
|
|
|
addToStore(info, make_ref<std::string>(narSource.drain()), repair, checkSigs, accessor);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Store::addToStore(const ValidPathInfo & info, const ref<std::string> & nar,
|
|
|
|
|
RepairFlag repair, CheckSigsFlag checkSigs,
|
|
|
|
|
std::shared_ptr<FSAccessor> accessor)
|
|
|
|
|
{
|
|
|
|
|
StringSource source(*nar);
|
|
|
|
|
addToStore(info, source, repair, checkSigs, accessor);
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "local-store.hh"
|
2006-11-30 20:35:36 +02:00
|
|
|
|
#include "remote-store.hh"
|
2006-11-30 19:43:04 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
|
|
2016-02-29 17:11:11 +02:00
|
|
|
|
RegisterStoreImplementation::Implementations * RegisterStoreImplementation::implementations = 0;
|
|
|
|
|
|
2019-02-21 12:44:25 +02:00
|
|
|
|
/* Split URI into protocol+hierarchy part and its parameter set. */
|
|
|
|
|
std::pair<std::string, Store::Params> splitUriAndParams(const std::string & uri_)
|
2006-11-30 19:43:04 +02:00
|
|
|
|
{
|
2016-04-29 17:26:16 +03:00
|
|
|
|
auto uri(uri_);
|
2019-02-21 12:44:25 +02:00
|
|
|
|
Store::Params params;
|
2016-04-29 17:26:16 +03:00
|
|
|
|
auto q = uri.find('?');
|
|
|
|
|
if (q != std::string::npos) {
|
|
|
|
|
for (auto s : tokenizeString<Strings>(uri.substr(q + 1), "&")) {
|
|
|
|
|
auto e = s.find('=');
|
2018-08-03 21:36:25 +03:00
|
|
|
|
if (e != std::string::npos) {
|
|
|
|
|
auto value = s.substr(e + 1);
|
|
|
|
|
std::string decoded;
|
|
|
|
|
for (size_t i = 0; i < value.size(); ) {
|
|
|
|
|
if (value[i] == '%') {
|
|
|
|
|
if (i + 2 >= value.size())
|
|
|
|
|
throw Error("invalid URI parameter '%s'", value);
|
|
|
|
|
try {
|
|
|
|
|
decoded += std::stoul(std::string(value, i + 1, 2), 0, 16);
|
|
|
|
|
i += 3;
|
|
|
|
|
} catch (...) {
|
|
|
|
|
throw Error("invalid URI parameter '%s'", value);
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
decoded += value[i++];
|
|
|
|
|
}
|
|
|
|
|
params[s.substr(0, e)] = decoded;
|
|
|
|
|
}
|
2016-04-29 17:26:16 +03:00
|
|
|
|
}
|
|
|
|
|
uri = uri_.substr(0, q);
|
|
|
|
|
}
|
2019-02-21 12:44:25 +02:00
|
|
|
|
return {uri, params};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ref<Store> openStore(const std::string & uri_,
|
|
|
|
|
const Store::Params & extraParams)
|
|
|
|
|
{
|
|
|
|
|
auto [uri, uriParams] = splitUriAndParams(uri_);
|
|
|
|
|
auto params = extraParams;
|
|
|
|
|
params.insert(uriParams.begin(), uriParams.end());
|
2016-04-29 17:26:16 +03:00
|
|
|
|
|
2016-02-29 17:11:11 +02:00
|
|
|
|
for (auto fun : *RegisterStoreImplementation::implementations) {
|
2016-04-29 17:26:16 +03:00
|
|
|
|
auto store = fun(uri, params);
|
2017-04-13 16:55:38 +03:00
|
|
|
|
if (store) {
|
2018-03-27 19:41:31 +03:00
|
|
|
|
store->warnUnknownSettings();
|
2017-04-13 16:55:38 +03:00
|
|
|
|
return ref<Store>(store);
|
|
|
|
|
}
|
2016-02-24 15:48:16 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-30 14:27:57 +03:00
|
|
|
|
throw Error("don't know how to open Nix store '%s'", uri);
|
2016-02-29 17:11:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-09-02 13:39:29 +03:00
|
|
|
|
StoreType getStoreType(const std::string & uri, const std::string & stateDir)
|
2016-02-29 17:11:11 +02:00
|
|
|
|
{
|
2016-09-02 13:39:29 +03:00
|
|
|
|
if (uri == "daemon") {
|
|
|
|
|
return tDaemon;
|
2017-10-24 16:16:18 +03:00
|
|
|
|
} else if (uri == "local" || hasPrefix(uri, "/")) {
|
2016-09-02 13:39:29 +03:00
|
|
|
|
return tLocal;
|
2017-04-06 20:01:05 +03:00
|
|
|
|
} else if (uri == "" || uri == "auto") {
|
2016-06-02 14:33:49 +03:00
|
|
|
|
if (access(stateDir.c_str(), R_OK | W_OK) == 0)
|
2016-09-02 13:39:29 +03:00
|
|
|
|
return tLocal;
|
2016-01-31 11:19:14 +02:00
|
|
|
|
else if (pathExists(settings.nixDaemonSocketFile))
|
2016-09-02 13:39:29 +03:00
|
|
|
|
return tDaemon;
|
2016-01-31 11:19:14 +02:00
|
|
|
|
else
|
2016-09-02 13:39:29 +03:00
|
|
|
|
return tLocal;
|
|
|
|
|
} else {
|
|
|
|
|
return tOther;
|
2016-01-31 11:19:14 +02:00
|
|
|
|
}
|
2016-02-29 17:11:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-29 17:26:16 +03:00
|
|
|
|
static RegisterStoreImplementation regStore([](
|
2016-06-01 15:49:12 +03:00
|
|
|
|
const std::string & uri, const Store::Params & params)
|
2016-04-29 17:26:16 +03:00
|
|
|
|
-> std::shared_ptr<Store>
|
|
|
|
|
{
|
2016-09-02 13:39:29 +03:00
|
|
|
|
switch (getStoreType(uri, get(params, "state", settings.nixStateDir))) {
|
|
|
|
|
case tDaemon:
|
2016-09-02 21:15:04 +03:00
|
|
|
|
return std::shared_ptr<Store>(std::make_shared<UDSRemoteStore>(params));
|
2017-10-24 16:16:18 +03:00
|
|
|
|
case tLocal: {
|
|
|
|
|
Store::Params params2 = params;
|
|
|
|
|
if (hasPrefix(uri, "/"))
|
|
|
|
|
params2["root"] = uri;
|
|
|
|
|
return std::shared_ptr<Store>(std::make_shared<LocalStore>(params2));
|
|
|
|
|
}
|
2016-09-02 13:39:29 +03:00
|
|
|
|
default:
|
|
|
|
|
return nullptr;
|
2016-01-31 11:19:14 +02:00
|
|
|
|
}
|
2016-02-29 17:11:11 +02:00
|
|
|
|
});
|
2016-02-24 15:48:16 +02:00
|
|
|
|
|
|
|
|
|
|
2016-04-29 14:57:08 +03:00
|
|
|
|
std::list<ref<Store>> getDefaultSubstituters()
|
|
|
|
|
{
|
2017-07-04 17:26:48 +03:00
|
|
|
|
static auto stores([]() {
|
2016-04-29 14:57:08 +03:00
|
|
|
|
std::list<ref<Store>> stores;
|
|
|
|
|
|
2017-07-04 17:26:48 +03:00
|
|
|
|
StringSet done;
|
2016-04-29 14:57:08 +03:00
|
|
|
|
|
2017-07-04 17:26:48 +03:00
|
|
|
|
auto addStore = [&](const std::string & uri) {
|
2019-10-09 16:51:52 +03:00
|
|
|
|
if (!done.insert(uri).second) return;
|
2018-02-09 15:36:38 +02:00
|
|
|
|
try {
|
|
|
|
|
stores.push_back(openStore(uri));
|
|
|
|
|
} catch (Error & e) {
|
|
|
|
|
printError("warning: %s", e.what());
|
|
|
|
|
}
|
2017-07-04 17:26:48 +03:00
|
|
|
|
};
|
2016-04-29 14:57:08 +03:00
|
|
|
|
|
2017-07-04 17:26:48 +03:00
|
|
|
|
for (auto uri : settings.substituters.get())
|
|
|
|
|
addStore(uri);
|
2017-03-21 18:59:18 +02:00
|
|
|
|
|
2017-07-04 17:26:48 +03:00
|
|
|
|
for (auto uri : settings.extraSubstituters.get())
|
|
|
|
|
addStore(uri);
|
2016-04-29 14:57:08 +03:00
|
|
|
|
|
2017-07-04 17:34:53 +03:00
|
|
|
|
stores.sort([](ref<Store> & a, ref<Store> & b) {
|
|
|
|
|
return a->getPriority() < b->getPriority();
|
|
|
|
|
});
|
|
|
|
|
|
2017-07-04 17:26:48 +03:00
|
|
|
|
return stores;
|
|
|
|
|
} ());
|
2016-04-29 14:57:08 +03:00
|
|
|
|
|
2017-07-04 17:26:48 +03:00
|
|
|
|
return stores;
|
2016-04-29 14:57:08 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-30 19:43:04 +02:00
|
|
|
|
}
|