nix-super/src/build-remote/build-remote.cc

309 lines
11 KiB
C++
Raw Normal View History

2016-07-19 01:50:27 +03:00
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <set>
2016-07-19 01:50:27 +03:00
#include <memory>
#include <tuple>
#include <iomanip>
2017-01-24 14:57:26 +02:00
#if __APPLE__
#include <sys/time.h>
#endif
2016-07-19 01:50:27 +03:00
#include "machines.hh"
2016-07-19 01:50:27 +03:00
#include "shared.hh"
#include "pathlocks.hh"
#include "globals.hh"
#include "serialise.hh"
#include "store-api.hh"
#include "derivations.hh"
#include "local-store.hh"
#include "../nix/legacy.hh"
2016-07-19 01:50:27 +03:00
using namespace nix;
using std::cin;
2017-03-03 17:18:49 +02:00
static void handleAlarm(int sig) {
2016-07-19 01:50:27 +03:00
}
std::string escapeUri(std::string uri)
{
std::replace(uri.begin(), uri.end(), '/', '_');
return uri;
}
2016-07-19 01:50:27 +03:00
static string currentLoad;
2020-07-30 14:10:49 +03:00
static AutoCloseFD openSlotLock(const Machine & m, uint64_t slot)
{
return openLockFile(fmt("%s/%s-%d", currentLoad, escapeUri(m.storeUri), slot), true);
2016-07-19 01:50:27 +03:00
}
static bool allSupportedLocally(Store & store, const std::set<std::string>& requiredFeatures) {
for (auto & feature : requiredFeatures)
if (!store.systemFeatures.get().count(feature)) return false;
return true;
}
static int main_build_remote(int argc, char * * argv)
2016-07-19 01:50:27 +03:00
{
{
logger = makeJSONLogger(*logger);
2016-07-19 01:50:27 +03:00
/* Ensure we don't get any SSH passphrase or host key popups. */
unsetenv("DISPLAY");
unsetenv("SSH_ASKPASS");
2016-07-19 01:50:27 +03:00
if (argc != 2)
2016-07-19 01:50:27 +03:00
throw UsageError("called without required arguments");
verbosity = (Verbosity) std::stoll(argv[1]);
FdSource source(STDIN_FILENO);
/* Read the parent's settings. */
while (readInt(source)) {
auto name = readString(source);
auto value = readString(source);
settings.set(name, value);
}
settings.maxBuildJobs.set("1"); // hack to make tests with local?root= work
2016-07-19 01:50:27 +03:00
initPlugins();
auto store = openStore().cast<LocalStore>();
2016-07-19 01:50:27 +03:00
/* It would be more appropriate to use $XDG_RUNTIME_DIR, since
2017-07-30 13:28:50 +03:00
that gets cleared on reboot, but it wouldn't work on macOS. */
currentLoad = store->stateDir + "/current-load";
2016-07-19 01:50:27 +03:00
std::shared_ptr<Store> sshStore;
AutoCloseFD bestSlotLock;
auto machines = getMachines();
2017-05-01 15:43:14 +03:00
debug("got %d remote builders", machines.size());
if (machines.empty()) {
std::cerr << "# decline-permanently\n";
return 0;
}
std::optional<StorePath> drvPath;
string storeUri;
while (true) {
try {
auto s = readString(source);
if (s != "try") return 0;
} catch (EndOfFile &) { return 0; }
auto amWilling = readInt(source);
auto neededSystem = readString(source);
drvPath = store->parseStorePath(readString(source));
auto requiredFeatures = readStrings<std::set<std::string>>(source);
2020-08-05 19:58:00 +03:00
auto canBuildLocally = amWilling
&& ( neededSystem == settings.thisSystem
|| settings.extraPlatforms.get().count(neededSystem) > 0)
&& allSupportedLocally(*store, requiredFeatures);
2016-07-19 01:50:27 +03:00
/* Error ignored here, will be caught later */
mkdir(currentLoad.c_str(), 0777);
while (true) {
bestSlotLock = -1;
AutoCloseFD lock = openLockFile(currentLoad + "/main-lock", true);
lockFile(lock.get(), ltWrite, true);
bool rightType = false;
2017-03-03 17:18:49 +02:00
Machine * bestMachine = nullptr;
2020-07-30 14:10:49 +03:00
uint64_t bestLoad = 0;
2016-07-19 01:50:27 +03:00
for (auto & m : machines) {
debug("considering building on remote machine '%s'", m.storeUri);
2016-07-19 01:50:27 +03:00
if (m.enabled && std::find(m.systemTypes.begin(),
m.systemTypes.end(),
neededSystem) != m.systemTypes.end() &&
m.allSupported(requiredFeatures) &&
m.mandatoryMet(requiredFeatures)) {
rightType = true;
AutoCloseFD free;
2020-07-30 14:10:49 +03:00
uint64_t load = 0;
for (uint64_t slot = 0; slot < m.maxJobs; ++slot) {
2017-01-25 13:51:35 +02:00
auto slotLock = openSlotLock(m, slot);
2016-07-19 01:50:27 +03:00
if (lockFile(slotLock.get(), ltWrite, false)) {
if (!free) {
free = std::move(slotLock);
}
} else {
++load;
}
}
if (!free) {
continue;
}
bool best = false;
if (!bestSlotLock) {
best = true;
} else if (load / m.speedFactor < bestLoad / bestMachine->speedFactor) {
best = true;
} else if (load / m.speedFactor == bestLoad / bestMachine->speedFactor) {
if (m.speedFactor > bestMachine->speedFactor) {
best = true;
} else if (m.speedFactor == bestMachine->speedFactor) {
if (load < bestLoad) {
best = true;
}
}
}
if (best) {
bestLoad = load;
bestSlotLock = std::move(free);
bestMachine = &m;
}
}
}
if (!bestSlotLock) {
2017-03-03 17:18:49 +02:00
if (rightType && !canBuildLocally)
std::cerr << "# postpone\n";
else
2020-08-05 19:58:00 +03:00
{
// build the hint template.
2020-08-05 20:21:36 +03:00
string hintstring = "derivation: %s\nrequired (system, features): (%s, %s)";
2020-08-05 19:58:00 +03:00
hintstring += "\n%s available machines:";
hintstring += "\n(systems, maxjobs, supportedFeatures, mandatoryFeatures)";
for (unsigned int i = 0; i < machines.size(); ++i) {
hintstring += "\n(%s, %s, %s, %s)";
}
// add the template values.
2020-08-05 20:26:06 +03:00
string drvstr;
if (drvPath.has_value())
drvstr = drvPath->to_string();
else
drvstr = "<unknown>";
2020-08-05 19:58:00 +03:00
auto hint = hintformat(hintstring);
hint
2020-08-05 20:26:06 +03:00
% drvstr
2020-08-05 19:58:00 +03:00
% neededSystem
% concatStringsSep<StringSet>(", ", requiredFeatures)
% machines.size();
for (auto & m : machines) {
hint % concatStringsSep<vector<string>>(", ", m.systemTypes)
% m.maxJobs
% concatStringsSep<StringSet>(", ", m.supportedFeatures)
% concatStringsSep<StringSet>(", ", m.mandatoryFeatures);
}
logErrorInfo(canBuildLocally ? lvlChatty : lvlWarn, {
2020-08-05 19:58:00 +03:00
.name = "Remote build",
.description = "Failed to find a machine for remote build!",
.hint = hint
});
2017-03-03 17:18:49 +02:00
std::cerr << "# decline\n";
2020-08-05 19:58:00 +03:00
}
2016-07-19 01:50:27 +03:00
break;
}
#if __APPLE__
futimes(bestSlotLock.get(), NULL);
#else
2016-07-19 01:50:27 +03:00
futimens(bestSlotLock.get(), NULL);
#endif
2016-07-19 01:50:27 +03:00
lock = -1;
try {
Activity act(*logger, lvlTalkative, actUnknown, fmt("connecting to '%s'", bestMachine->storeUri));
sshStore = bestMachine->openStore();
sshStore->connect();
storeUri = bestMachine->storeUri;
2016-07-19 01:50:27 +03:00
} catch (std::exception & e) {
auto msg = chomp(drainFD(5, false));
2020-06-15 15:12:39 +03:00
logError({
.name = "Remote build",
.hint = hintfmt("cannot build on '%s': %s%s",
bestMachine->storeUri, e.what(),
(msg.empty() ? "" : ": " + msg))
});
2016-07-19 01:50:27 +03:00
bestMachine->enabled = false;
continue;
}
2016-07-19 01:50:27 +03:00
goto connected;
}
}
2017-03-03 17:18:49 +02:00
2016-07-19 01:50:27 +03:00
connected:
close(5);
assert(sshStore);
auto sshStore2 = ref<Store>(sshStore);
std::cerr << "# accept\n" << storeUri << "\n";
auto inputs = readStrings<PathSet>(source);
auto outputs = readStrings<PathSet>(source);
AutoCloseFD uploadLock = openLockFile(currentLoad + "/" + escapeUri(storeUri) + ".upload-lock", true);
{
Activity act(*logger, lvlTalkative, actUnknown, fmt("waiting for the upload lock to '%s'", storeUri));
auto old = signal(SIGALRM, handleAlarm);
alarm(15 * 60);
if (!lockFile(uploadLock.get(), ltWrite, true))
printError("somebody is hogging the upload lock for '%s', continuing...");
alarm(0);
signal(SIGALRM, old);
}
auto substitute = settings.buildersUseSubstitutes ? Substitute : NoSubstitute;
{
Activity act(*logger, lvlTalkative, actUnknown, fmt("copying dependencies to '%s'", storeUri));
copyPaths(store, sshStore2, store->parseStorePathSet(inputs), NoRepair, NoCheckSigs, substitute);
}
2016-07-19 01:50:27 +03:00
uploadLock = -1;
BasicDerivation drv = store->readDerivation(*drvPath);
if (sshStore2->isTrusting || derivationIsCA(drv.type())) {
drv.inputSrcs = store->parseStorePathSet(inputs);
auto result = sshStore2->buildDerivation(*drvPath, drv);
if (!result.success())
throw Error("build of '%s' on '%s' failed: %s", store->printStorePath(*drvPath), storeUri, result.errorMsg);
} else {
copyPaths(store, sshStore2, {*drvPath}, NoRepair, NoCheckSigs, substitute);
sshStore2->buildPaths({{*drvPath}});
}
2016-07-19 01:50:27 +03:00
StorePathSet missing;
for (auto & path : outputs)
if (!store->isValidPath(store->parseStorePath(path))) missing.insert(store->parseStorePath(path));
if (!missing.empty()) {
Activity act(*logger, lvlTalkative, actUnknown, fmt("copying outputs from '%s'", storeUri));
for (auto & i : missing)
store->locksHeld.insert(store->printStorePath(i)); /* FIXME: ugly */
copyPaths(sshStore2, store, missing, NoRepair, NoCheckSigs, NoSubstitute);
2016-07-19 01:50:27 +03:00
}
return 0;
}
2016-07-19 01:50:27 +03:00
}
static RegisterLegacyCommand r_build_remote("build-remote", main_build_remote);