mirror of
https://github.com/NixOS/nix
synced 2024-09-20 11:11:03 -04:00
11800e6198
Getting substitute information using the binary cache substituter has non-trivial latency overhead. A package or NixOS system configuration can have hundreds of dependencies, and in the worst case (when the local info cache is empty) we have to do a separate HTTP request for each of these. If the ping time to the server is t, getting N info files will take tN seconds; e.g., with a ping time of 0.1s to nixos.org, sequentially downloading 1000 info files (a typical NixOS config) will take at least 100 seconds. To fix this problem, the binary cache substituter can now perform requests in parallel. This required changing the substituter interface to support a function querySubstitutablePathInfos() that queries multiple paths at the same time, and rewriting queryMissing() to take advantage of parallelism. (Due to local caching, parallelising queryMissing() is sufficient for most use cases, since it's almost always called before building a derivation and thus fills the local info cache.) For example, parallelism speeds up querying all 1056 paths in a particular NixOS system configuration from 116s to 2.6s. It works so well because the eccentricity of the top-level derivation in the dependency graph is only 9. So we only need 10 round-trips (when using an unlimited number of parallel connections) to get everything. Currently we do a maximum of 150 parallel connections to the server. Thus it's important that the binary cache server (e.g. nixos.org) has a high connection limit. Alternatively we could use HTTP pipelining, but WWW::Curl doesn't support it and libcurl has a hard-coded limit of 5 requests per pipeline.
556 lines
14 KiB
C++
556 lines
14 KiB
C++
#include "serialise.hh"
|
|
#include "util.hh"
|
|
#include "remote-store.hh"
|
|
#include "worker-protocol.hh"
|
|
#include "archive.hh"
|
|
#include "globals.hh"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <fcntl.h>
|
|
|
|
#include <iostream>
|
|
#include <unistd.h>
|
|
#include <cstring>
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
Path readStorePath(Source & from)
|
|
{
|
|
Path path = readString(from);
|
|
assertStorePath(path);
|
|
return path;
|
|
}
|
|
|
|
|
|
template<class T> T readStorePaths(Source & from)
|
|
{
|
|
T paths = readStrings<T>(from);
|
|
foreach (typename T::iterator, i, paths) assertStorePath(*i);
|
|
return paths;
|
|
}
|
|
|
|
template PathSet readStorePaths(Source & from);
|
|
|
|
|
|
RemoteStore::RemoteStore()
|
|
{
|
|
initialised = false;
|
|
}
|
|
|
|
|
|
void RemoteStore::openConnection(bool reserveSpace)
|
|
{
|
|
if (initialised) return;
|
|
initialised = true;
|
|
|
|
string remoteMode = getEnv("NIX_REMOTE");
|
|
|
|
if (remoteMode == "slave")
|
|
/* Fork off a setuid worker to do the privileged work. */
|
|
forkSlave();
|
|
else if (remoteMode == "daemon")
|
|
/* Connect to a daemon that does the privileged work for
|
|
us. */
|
|
connectToDaemon();
|
|
else
|
|
throw Error(format("invalid setting for NIX_REMOTE, `%1%'")
|
|
% remoteMode);
|
|
|
|
from.fd = fdSocket;
|
|
to.fd = fdSocket;
|
|
|
|
/* Send the magic greeting, check for the reply. */
|
|
try {
|
|
writeInt(WORKER_MAGIC_1, to);
|
|
to.flush();
|
|
unsigned int magic = readInt(from);
|
|
if (magic != WORKER_MAGIC_2) throw Error("protocol mismatch");
|
|
|
|
daemonVersion = readInt(from);
|
|
if (GET_PROTOCOL_MAJOR(daemonVersion) != GET_PROTOCOL_MAJOR(PROTOCOL_VERSION))
|
|
throw Error("Nix daemon protocol version not supported");
|
|
writeInt(PROTOCOL_VERSION, to);
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) >= 11)
|
|
writeInt(reserveSpace, to);
|
|
processStderr();
|
|
}
|
|
catch (Error & e) {
|
|
throw Error(format("cannot start worker (%1%)")
|
|
% e.msg());
|
|
}
|
|
|
|
setOptions();
|
|
}
|
|
|
|
|
|
void RemoteStore::forkSlave()
|
|
{
|
|
int sockets[2];
|
|
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == -1)
|
|
throw SysError("cannot create sockets");
|
|
|
|
fdSocket = sockets[0];
|
|
AutoCloseFD fdChild = sockets[1];
|
|
|
|
/* Start the worker. */
|
|
Path worker = getEnv("NIX_WORKER");
|
|
if (worker == "")
|
|
worker = nixBinDir + "/nix-worker";
|
|
|
|
child = fork();
|
|
|
|
switch (child) {
|
|
|
|
case -1:
|
|
throw SysError("unable to fork");
|
|
|
|
case 0:
|
|
try { /* child */
|
|
|
|
if (dup2(fdChild, STDOUT_FILENO) == -1)
|
|
throw SysError("dupping write side");
|
|
|
|
if (dup2(fdChild, STDIN_FILENO) == -1)
|
|
throw SysError("dupping read side");
|
|
|
|
close(fdSocket);
|
|
close(fdChild);
|
|
|
|
execlp(worker.c_str(), worker.c_str(), "--slave", NULL);
|
|
|
|
throw SysError(format("executing `%1%'") % worker);
|
|
|
|
} catch (std::exception & e) {
|
|
std::cerr << format("child error: %1%\n") % e.what();
|
|
}
|
|
quickExit(1);
|
|
}
|
|
|
|
fdChild.close();
|
|
|
|
}
|
|
|
|
|
|
void RemoteStore::connectToDaemon()
|
|
{
|
|
fdSocket = socket(PF_UNIX, SOCK_STREAM, 0);
|
|
if (fdSocket == -1)
|
|
throw SysError("cannot create Unix domain socket");
|
|
|
|
string socketPath = nixStateDir + DEFAULT_SOCKET_PATH;
|
|
|
|
/* Urgh, sockaddr_un allows path names of only 108 characters. So
|
|
chdir to the socket directory so that we can pass a relative
|
|
path name. !!! this is probably a bad idea in multi-threaded
|
|
applications... */
|
|
AutoCloseFD fdPrevDir = open(".", O_RDONLY);
|
|
if (fdPrevDir == -1) throw SysError("couldn't open current directory");
|
|
chdir(dirOf(socketPath).c_str());
|
|
Path socketPathRel = "./" + baseNameOf(socketPath);
|
|
|
|
struct sockaddr_un addr;
|
|
addr.sun_family = AF_UNIX;
|
|
if (socketPathRel.size() >= sizeof(addr.sun_path))
|
|
throw Error(format("socket path `%1%' is too long") % socketPathRel);
|
|
using namespace std;
|
|
strcpy(addr.sun_path, socketPathRel.c_str());
|
|
|
|
if (connect(fdSocket, (struct sockaddr *) &addr, sizeof(addr)) == -1)
|
|
throw SysError(format("cannot connect to daemon at `%1%'") % socketPath);
|
|
|
|
if (fchdir(fdPrevDir) == -1)
|
|
throw SysError("couldn't change back to previous directory");
|
|
}
|
|
|
|
|
|
RemoteStore::~RemoteStore()
|
|
{
|
|
try {
|
|
to.flush();
|
|
fdSocket.close();
|
|
if (child != -1)
|
|
child.wait(true);
|
|
} catch (...) {
|
|
ignoreException();
|
|
}
|
|
}
|
|
|
|
|
|
void RemoteStore::setOptions()
|
|
{
|
|
writeInt(wopSetOptions, to);
|
|
writeInt(keepFailed, to);
|
|
writeInt(keepGoing, to);
|
|
writeInt(tryFallback, to);
|
|
writeInt(verbosity, to);
|
|
writeInt(maxBuildJobs, to);
|
|
writeInt(maxSilentTime, to);
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) >= 2)
|
|
writeInt(useBuildHook, to);
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) >= 4) {
|
|
writeInt(buildVerbosity, to);
|
|
writeInt(logType, to);
|
|
writeInt(printBuildTrace, to);
|
|
}
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) >= 6)
|
|
writeInt(buildCores, to);
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) >= 10)
|
|
writeInt(queryBoolSetting("build-use-substitutes", true), to);
|
|
|
|
processStderr();
|
|
}
|
|
|
|
|
|
bool RemoteStore::isValidPath(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopIsValidPath, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
unsigned int reply = readInt(from);
|
|
return reply != 0;
|
|
}
|
|
|
|
|
|
PathSet RemoteStore::queryValidPaths()
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryValidPaths, to);
|
|
processStderr();
|
|
return readStorePaths<PathSet>(from);
|
|
}
|
|
|
|
|
|
bool RemoteStore::hasSubstitutes(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopHasSubstitutes, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
unsigned int reply = readInt(from);
|
|
return reply != 0;
|
|
}
|
|
|
|
|
|
bool RemoteStore::querySubstitutablePathInfo(const Path & path,
|
|
SubstitutablePathInfo & info)
|
|
{
|
|
openConnection();
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) < 3) return false;
|
|
writeInt(wopQuerySubstitutablePathInfo, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
unsigned int reply = readInt(from);
|
|
if (reply == 0) return false;
|
|
info.deriver = readString(from);
|
|
if (info.deriver != "") assertStorePath(info.deriver);
|
|
info.references = readStorePaths<PathSet>(from);
|
|
info.downloadSize = readLongLong(from);
|
|
info.narSize = GET_PROTOCOL_MINOR(daemonVersion) >= 7 ? readLongLong(from) : 0;
|
|
return true;
|
|
}
|
|
|
|
|
|
void RemoteStore::querySubstitutablePathInfos(const PathSet & paths,
|
|
SubstitutablePathInfos & infos)
|
|
{
|
|
if (paths.empty()) return;
|
|
printMsg(lvlError, format("QUERYING %1% (REMOTE)") % showPaths(paths));
|
|
foreach (PathSet::const_iterator, i, paths) {
|
|
SubstitutablePathInfo info;
|
|
if (querySubstitutablePathInfo(*i, info))
|
|
infos[*i] = info;
|
|
}
|
|
}
|
|
|
|
|
|
ValidPathInfo RemoteStore::queryPathInfo(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryPathInfo, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
ValidPathInfo info;
|
|
info.path = path;
|
|
info.deriver = readString(from);
|
|
if (info.deriver != "") assertStorePath(info.deriver);
|
|
info.hash = parseHash(htSHA256, readString(from));
|
|
info.references = readStorePaths<PathSet>(from);
|
|
info.registrationTime = readInt(from);
|
|
info.narSize = readLongLong(from);
|
|
return info;
|
|
}
|
|
|
|
|
|
Hash RemoteStore::queryPathHash(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryPathHash, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
string hash = readString(from);
|
|
return parseHash(htSHA256, hash);
|
|
}
|
|
|
|
|
|
void RemoteStore::queryReferences(const Path & path,
|
|
PathSet & references)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryReferences, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
PathSet references2 = readStorePaths<PathSet>(from);
|
|
references.insert(references2.begin(), references2.end());
|
|
}
|
|
|
|
|
|
void RemoteStore::queryReferrers(const Path & path,
|
|
PathSet & referrers)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryReferrers, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
PathSet referrers2 = readStorePaths<PathSet>(from);
|
|
referrers.insert(referrers2.begin(), referrers2.end());
|
|
}
|
|
|
|
|
|
Path RemoteStore::queryDeriver(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryDeriver, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
Path drvPath = readString(from);
|
|
if (drvPath != "") assertStorePath(drvPath);
|
|
return drvPath;
|
|
}
|
|
|
|
|
|
PathSet RemoteStore::queryDerivationOutputs(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryDerivationOutputs, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
return readStorePaths<PathSet>(from);
|
|
}
|
|
|
|
|
|
PathSet RemoteStore::queryDerivationOutputNames(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryDerivationOutputNames, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
return readStrings<PathSet>(from);
|
|
}
|
|
|
|
|
|
Path RemoteStore::addToStore(const Path & _srcPath,
|
|
bool recursive, HashType hashAlgo, PathFilter & filter)
|
|
{
|
|
openConnection();
|
|
|
|
Path srcPath(absPath(_srcPath));
|
|
|
|
writeInt(wopAddToStore, to);
|
|
writeString(baseNameOf(srcPath), to);
|
|
/* backwards compatibility hack */
|
|
writeInt((hashAlgo == htSHA256 && recursive) ? 0 : 1, to);
|
|
writeInt(recursive ? 1 : 0, to);
|
|
writeString(printHashType(hashAlgo), to);
|
|
dumpPath(srcPath, to, filter);
|
|
processStderr();
|
|
return readStorePath(from);
|
|
}
|
|
|
|
|
|
Path RemoteStore::addTextToStore(const string & name, const string & s,
|
|
const PathSet & references)
|
|
{
|
|
openConnection();
|
|
writeInt(wopAddTextToStore, to);
|
|
writeString(name, to);
|
|
writeString(s, to);
|
|
writeStrings(references, to);
|
|
|
|
processStderr();
|
|
return readStorePath(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::exportPath(const Path & path, bool sign,
|
|
Sink & sink)
|
|
{
|
|
openConnection();
|
|
writeInt(wopExportPath, to);
|
|
writeString(path, to);
|
|
writeInt(sign ? 1 : 0, to);
|
|
processStderr(&sink); /* sink receives the actual data */
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
Paths RemoteStore::importPaths(bool requireSignature, Source & source)
|
|
{
|
|
openConnection();
|
|
writeInt(wopImportPaths, to);
|
|
/* We ignore requireSignature, since the worker forces it to true
|
|
anyway. */
|
|
processStderr(0, &source);
|
|
return readStorePaths<Paths>(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::buildPaths(const PathSet & drvPaths)
|
|
{
|
|
openConnection();
|
|
writeInt(wopBuildPaths, to);
|
|
writeStrings(drvPaths, to);
|
|
processStderr();
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::ensurePath(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopEnsurePath, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::addTempRoot(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopAddTempRoot, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::addIndirectRoot(const Path & path)
|
|
{
|
|
openConnection();
|
|
writeInt(wopAddIndirectRoot, to);
|
|
writeString(path, to);
|
|
processStderr();
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::syncWithGC()
|
|
{
|
|
openConnection();
|
|
writeInt(wopSyncWithGC, to);
|
|
processStderr();
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
Roots RemoteStore::findRoots()
|
|
{
|
|
openConnection();
|
|
writeInt(wopFindRoots, to);
|
|
processStderr();
|
|
unsigned int count = readInt(from);
|
|
Roots result;
|
|
while (count--) {
|
|
Path link = readString(from);
|
|
Path target = readStorePath(from);
|
|
result[link] = target;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
void RemoteStore::collectGarbage(const GCOptions & options, GCResults & results)
|
|
{
|
|
openConnection(false);
|
|
|
|
writeInt(wopCollectGarbage, to);
|
|
writeInt(options.action, to);
|
|
writeStrings(options.pathsToDelete, to);
|
|
writeInt(options.ignoreLiveness, to);
|
|
writeLongLong(options.maxFreed, to);
|
|
writeInt(0, to);
|
|
if (GET_PROTOCOL_MINOR(daemonVersion) >= 5) {
|
|
/* removed options */
|
|
writeInt(0, to);
|
|
writeInt(0, to);
|
|
}
|
|
|
|
processStderr();
|
|
|
|
results.paths = readStrings<PathSet>(from);
|
|
results.bytesFreed = readLongLong(from);
|
|
results.blocksFreed = readLongLong(from);
|
|
}
|
|
|
|
|
|
PathSet RemoteStore::queryFailedPaths()
|
|
{
|
|
openConnection();
|
|
writeInt(wopQueryFailedPaths, to);
|
|
processStderr();
|
|
return readStorePaths<PathSet>(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::clearFailedPaths(const PathSet & paths)
|
|
{
|
|
openConnection();
|
|
writeInt(wopClearFailedPaths, to);
|
|
writeStrings(paths, to);
|
|
processStderr();
|
|
readInt(from);
|
|
}
|
|
|
|
|
|
void RemoteStore::processStderr(Sink * sink, Source * source)
|
|
{
|
|
to.flush();
|
|
unsigned int msg;
|
|
while ((msg = readInt(from)) == STDERR_NEXT
|
|
|| msg == STDERR_READ || msg == STDERR_WRITE) {
|
|
if (msg == STDERR_WRITE) {
|
|
string s = readString(from);
|
|
if (!sink) throw Error("no sink");
|
|
(*sink)((const unsigned char *) s.data(), s.size());
|
|
}
|
|
else if (msg == STDERR_READ) {
|
|
if (!source) throw Error("no source");
|
|
size_t len = readInt(from);
|
|
unsigned char * buf = new unsigned char[len];
|
|
AutoDeleteArray<unsigned char> d(buf);
|
|
writeString(buf, source->read(buf, len), to);
|
|
to.flush();
|
|
}
|
|
else {
|
|
string s = readString(from);
|
|
writeToStderr((const unsigned char *) s.data(), s.size());
|
|
}
|
|
}
|
|
if (msg == STDERR_ERROR) {
|
|
string error = readString(from);
|
|
unsigned int status = GET_PROTOCOL_MINOR(daemonVersion) >= 8 ? readInt(from) : 1;
|
|
throw Error(format("%1%") % error, status);
|
|
}
|
|
else if (msg != STDERR_LAST)
|
|
throw Error("protocol error processing standard error");
|
|
}
|
|
|
|
|
|
}
|