Build against nix-master

[?]

Dec 30, 2019, 9:49 PM

WV4SSAIYM4SVBQ2VISDTAXQJCPKRGTLSVFH44CQFEMC4COWG5OKQC

Dependencies

[2] OJFOBJKF Add FIXME
[3] YE6LD6MF hydra-queue-runner: Recycle finishedDrvs
[4] 6LIYTMFU Fix build failure on GCC 5.4
[5] 3YSJ3LYK Remove finally.hh
[6] DRC26KFB hydra-queue-runner: Fix a race keeping cancelled steps alive
[7] RNJILKTW Upload log files to the right location
[8] XZYFFHLQ hydra-queue-runner: Set a thread title for the builder threads
[9] FJCKDJKB Acquire the send lock only while actually sending
[10] LENA4O2V Periodically close RemoteStore connections
[11] SGFLU2VS USER -> LOGNAME for consistency
[12] INVXGPNK Fix root creation when the root already exists but is owned by another user
[13] WDQJRLNA Handle derivations with system type 'builtin'
[14] QAPR72LX Add some debug code
[15] FJ5H26J6 Fix building against nix master
[16] 2GRQJZT6 hydra-queue-runner: Support running in a NixOS container
[17] WCXHTOWH Disable deprecation warnings
[18] OKEMZJLS Bump Nix
[19] FS3HUMVU Fix Makefile.am
[20] NJJ7H64S Very basic multi-threaded queue runner
[21] MSIHMO45 Tweak build steps
[22] 32KJOERM Turn hydra-notify into a daemon
[23] M3A5PZIH hydra: Clarify the dependency on BDW-GC.
[24] GH4S4AWM Rename file
[25] 2DNPZFPN Step cancellation: Don't use pthread_cancel()
[26] YTAYNN7V Queue monitor: Bail out earlier if a step has failed previously
[27] WHULPA6S Handle failure with output
[28] IK2UBDAU Revive jobset scheduling
[29] 24BMQDZA Start of single-process hydra-queue-runner
[30] BYVRA54Q Temporarily disable machines on any exception, not just connection failures
[31] 3BKPZ52C Disambiguate "marking build as succeeded" message
[32] UYUVQWXQ Fix hydra-queue-runner --build-one
[33] FITVNQ2S Keep track of the time we spend copying to/from build machines
[34] KNLKTCDM Use pkgconfig to find Nix
[35] EFWDY2V7 Support testing build determinism
[36] NSBNNM77 Add hydra.conf option "nar_buffer_size" to configure memoryTokens limit
[37] XIFDDTXZ Don't lock the BuildSteps table when inserting
[38] G7KWXSFM Distinguish build step states
[39] V6H6BWMK Sync with Nix
[40] DYVETV7L hydra-queue-runner: Allow multiple concurrent daemon connections
[41] WE5Q2NVI Allow build to be bumped to the front of the queue via the web interface
[42] UVQJBDHN Move log compression to a plugin
[43] 77VF5TC6 * For ease of use during debugging, don't require --gc-roots-dir.
[44] 4ZJIJCVF Slight cleanup
[45] HUUZFPPK Fix race between the queue monitor and the builder threads
[46] NKQOEVVP Get rid of "will retry" messages after "maybe cancelling..."
[47] KBZHIGLG Record the machine used for a build step
[48] 5CNQUQ77 Bump Nix
[49] PIMGMGAF Rename hydra_eval_jobs to hydra-eval-jobs
[50] VQISTKOP hydra-queue-runner: Use substitutes
[51] 4YCF3KBG Concurrent hydra-evaluator
[52] OBOTGFG6 Prevent orphaned build steps
[53] 6TY4LNHH Finish copyClosure
[54] FHVJYJFE Upload build logs to the binary cache
[55] OKQLN5AG Set proper charset on log files
[56] O3NM62IZ Support multiple machines files
[57] GTUZLZRH Add an S3-backed binary cache store
[58] N2NKSKHS Refactor local binary cache code into a subclass
[59] 46ADBTMQ Start steps in order of ascending build ID
[60] CNLNT3T4 Allow only 1 thread to send a closure to a given machine at the same time
[61] ZVSHXE3K Allow setting GC_INITIAL_HEAP_SIZE for hydra-eval-jobs
[62] 7LB6QBXY Keep track of the number of build steps that are being built
[63] UQQ4IL55 Add a error type for "unsupported system type"
[64] YHP5DSOO Improve parsing of hydra-build-products
[65] MHVIT4JY Split hydra-queue-runner.cc more
[66] EPWEMRI2 Allow determinism checking for entire jobsets
[67] HHOMBU7G hydra-queue-runner: Implement timeouts
[68] OG3Z3QGC Namespace cleanup
[69] LVQXQIYA Kill active build steps when builds are cancelled
[70] MB3TISH2 Rate-limit the number of threads copying closures at the same time
[71] FV2M6MOT hydra: use autoconf/-make
[72] H7SZRHUB Use nix::willBuildLocally()
[73] A63IHCMX * Register GC roots properly.
[74] 7LWB2J2Z Periodically clear orphaned build steps
[75] HJOEIMLR Refactor
[76] 5LBMP7GA Fix remote building
[77] 5N7LVAJN Keep track of requiredSystemFeatures in the machine stats
[78] B2L4T3X6 Sync with Nix
[79] PQFOMNTL hydra-queue-runner: More stats
[80] 5AIYUMTB Basic remote building
[81] TTBLPQAJ Keep track of wait time per system type
[82] 7VQ4ALFY Update "make check" for the new queue runner
[83] BRAESISH Warn if PostgreSQL appears stalled
[84] A2GL5FOZ Moar stats
[85] YXYXJDMB hydra-queue-runner: Write GC roots for outputs paths
[86] PW4TLMWS Sync with latest Nix
[87] YNO7CQ6P hydra-queue-runner: More accurate memory accounting
[88] N4IROACV Move buildRemote() into State
[89] GS4BE6TB Asynchronously compress build logs
[90] 25MFPBZV Keep track of time required to load builds
[91] SODOV2CM Automatically reload $NIX_REMOTE_SYSTEMS when it changes
[92] T5BIOVJE Add support for tracking custom metrics
[93] EJJCY263 Account steps with preferLocalBuild as a separate system type
[94] DKJFD6JN Process Nix API changes
[95] KS7NNPQW Bleh Automake
[96] IWB3F4Z6 Fail builds with previously failed steps early
[97] 2PQPKMG7 S3BinaryCacheStore: Use disk cache
[98] 4GTOWRFW hydra-eval-jobs: Fix build
[99] BG6PEOB2 Make the output size limit configurable
[100] SL3WSRAC hydra-queue-runner: Limit memory usage
[101] NAYQT2GT hydra-queue-runner: Use cmdBuildDerivation
[102] D6VR5FYG * Fix hydra_eval_jobs.
[103] F57YJP5P Build against latest Nix
[104] LE4VZIY5 More stats
[105] XCDTFZUY hydra-queue-runner: Fix build
[106] IGLIPGT6 Make maxLogSize configurable
[107] EYR3EW6J Keep stats for the Hydra auto scaler
[108] 7CCLJLW7 Remove superfluous "has" function
[109] YR2IM6Y5 Temporarily disable machines after a connection failure
[110] RND7XFNH getQueuedBuilds(): Periodically stop to handle priority bumps
[111] UNVMKJV5 Unify build and step status codes
[112] L2IBPED2 Typo
[113] BAFICF73 Support hydra-build-products on binary cache stores
[114] BUEWVH2M Remove signing parameter (nix#f435f82)
[115] IKJBYIGY Update to reflect BinaryCacheStore changes
[116] UVNTWTWG Prevent download of NARs we just uploaded
[117] ACBS7C6Q hydra-queue-runner: Detect changes to the scheduling shares
[118] WDGARQ76 Reuse build products / metrics stored in the database
[119] ZK76B5ZZ Load the queue in order of global priority
[120] 62MQPRXC Pass null values to libpqxx properly
[121] DIEY5USN Keep better bytesReceived/bytesSent stats
[122] 4NU5JJFD Truncate the log just before starting the remote build
[123] 6EO3HVNA Merge remote-tracking branch 'origin/master' into binary-cache
[124] 73YR46NJ hydra-queue-runner: Write directly to a binary cache
[125] LSUX6IQR Update to latest nixUnstable
[*] 4N5APGRG * Start of a helper tool to evaluate job expressions efficiently.

Change contents

replacement in src/hydra-eval-jobs/Makefile.am at line 4

[18.77]→[18.282:318](∅→∅)

hydra_eval_jobs_LDADD = $(NIX_LIBS)

[18.77]

[18.0]

hydra_eval_jobs_LDADD = $(NIX_LIBS) -lnixrust
replacement in src/hydra-eval-jobs/hydra-eval-jobs.cc at line 150

[18.275]→[18.36:104](∅→∅),[18.36]→[18.36:104](∅→∅),[18.104]→[18.276:362](∅→∅)

Path root = gcRootsDir + "/" + baseNameOf(drvPath);
if (!pathExists(root)) localStore->addPermRoot(drvPath, root, false);

[18.275]

[18.178]

Path root = gcRootsDir + "/" + std::string(baseNameOf(drvPath));
if (!pathExists(root))
localStore->addPermRoot(localStore->parseStorePath(drvPath), root, false);
replacement in src/hydra-queue-runner/Makefile.am at line 6

[18.45]→[18.322:368](∅→∅),[5.59]→[18.322:368](∅→∅),[18.65]→[18.322:368](∅→∅),[18.67]→[18.322:368](∅→∅),[18.75]→[18.322:368](∅→∅),[18.83]→[18.322:368](∅→∅),[18.91]→[18.322:368](∅→∅),[18.104]→[18.322:368](∅→∅),[18.112]→[18.322:368](∅→∅),[18.122]→[18.322:368](∅→∅),[18.161]→[18.322:368](∅→∅),[18.229]→[18.322:368](∅→∅),[18.322]→[18.322:368](∅→∅)

hydra_queue_runner_LDADD = $(NIX_LIBS) -lpqxx

[5.59]

[17.92]

hydra_queue_runner_LDADD = $(NIX_LIBS) -lpqxx -lnixrust
replacement in src/hydra-queue-runner/build-remote.cc at line 85

[9.78]→[18.1349:1406](∅→∅),[18.171]→[18.1349:1406](∅→∅),[18.183]→[18.1349:1406](∅→∅),[18.1349]→[18.1349:1406](∅→∅)

FdSource & from, FdSink & to, const PathSet & paths,

[9.78]

[18.1406]

FdSource & from, FdSink & to, const StorePathSet & paths,
replacement in src/hydra-queue-runner/build-remote.cc at line 88

[18.1441]→[18.1441:1462](∅→∅)

PathSet closure;

[18.1441]

[18.1462]

StorePathSet closure;
replacement in src/hydra-queue-runner/build-remote.cc at line 97

[2.55]→[18.0:64](∅→∅),[18.1844]→[18.0:64](∅→∅)

to << cmdQueryValidPaths << 1 << useSubstitutes << closure;

[2.55]

[18.1984]

to << cmdQueryValidPaths << 1 << useSubstitutes;
writeStorePaths(*destStore, to, closure);
replacement in src/hydra-queue-runner/build-remote.cc at line 103

[18.2087]→[18.250:312](∅→∅)

auto present = readStorePaths<PathSet>(*destStore, from);

[18.2087]

[18.2137]

auto present = readStorePaths<StorePathSet>(*destStore, from);
replacement in src/hydra-queue-runner/build-remote.cc at line 107

[18.83]→[18.225:279](∅→∅)

Paths sorted = destStore->topoSortPaths(closure);

[18.83]

[18.134]

auto sorted = destStore->topoSortPaths(closure);
replacement in src/hydra-queue-runner/build-remote.cc at line 109

[18.135]→[18.135:154](∅→∅)

Paths missing;

[18.135]

[18.154]

StorePathSet missing;
replacement in src/hydra-queue-runner/build-remote.cc at line 111

[18.214]→[18.214:284](∅→∅)

if (present.find(*i) == present.end()) missing.push_back(*i);

[18.214]

[18.398]

if (!present.count(*i)) missing.insert(i->clone());
replacement in src/hydra-queue-runner/build-remote.cc at line 135

[18.177]→[18.302:347](∅→∅),[18.2927]→[18.302:347](∅→∅)

string base = baseNameOf(step->drvPath);

[18.177]

[18.0]

string base(step->drvPath.to_string());
replacement in src/hydra-queue-runner/build-remote.cc at line 221

[18.321]→[18.1633:1702](∅→∅),[18.1633]→[18.1633:1702](∅→∅)

PathSet inputs;
BasicDerivation basicDrv(step->drv);

[18.321]

[18.650]

StorePathSet inputs;
BasicDerivation basicDrv(*step->drv);
replacement in src/hydra-queue-runner/build-remote.cc at line 225

[18.1731]→[18.1731:1773](∅→∅)

inputs.insert(step->drvPath);

[18.1731]

[18.1773]

inputs.insert(step->drvPath.clone());
replacement in src/hydra-queue-runner/build-remote.cc at line 227

[18.1786]→[18.1786:1869](∅→∅)

for (auto & p : step->drv.inputSrcs)
inputs.insert(p);

[18.1786]

[18.797]

for (auto & p : step->drv->inputSrcs)
inputs.insert(p.clone());
replacement in src/hydra-queue-runner/build-remote.cc at line 230

[18.798]→[18.1870:1980](∅→∅)

for (auto & input : step->drv.inputDrvs) {
Derivation drv2 = readDerivation(input.first);

[18.798]

[18.1980]

for (auto & input : step->drv->inputDrvs) {
Derivation drv2 = readDerivation(*localStore, localStore->printStorePath(input.first));
replacement in src/hydra-queue-runner/build-remote.cc at line 235

[18.2132]→[18.2132:2238](∅→∅)

inputs.insert(i->second.path);
basicDrv.inputSrcs.insert(i->second.path);

[18.2132]

[18.2238]

inputs.insert(i->second.path.clone());
basicDrv.inputSrcs.insert(i->second.path.clone());
replacement in src/hydra-queue-runner/build-remote.cc at line 245

[16.414]→[16.414:518](∅→∅)

copyClosure(ref<Store>(localStore), destStore, step->drv.inputSrcs, NoRepair, NoCheckSigs);

[16.414]

[18.3876]

copyClosure(ref<Store>(localStore), destStore, step->drv->inputSrcs, NoRepair, NoCheckSigs);
replacement in src/hydra-queue-runner/build-remote.cc at line 252

[18.140]→[18.2861:2981](∅→∅),[18.2861]→[18.2861:2981](∅→∅)

printMsg(lvlDebug, format("sending closure of ‘%1%’ to ‘%2%’") % step->drvPath % machine->sshName);

[18.140]

[18.0]

printMsg(lvlDebug, "sending closure of ‘%s’ to ‘%s’",
localStore->printStorePath(step->drvPath), machine->sshName);
replacement in src/hydra-queue-runner/build-remote.cc at line 277

[18.3339]→[18.3339:3445](∅→∅)

printMsg(lvlDebug, format("building ‘%1%’ on ‘%2%’") % step->drvPath % machine->sshName);

[18.3339]

[18.894]

printMsg(lvlDebug, "building ‘%s’ on ‘%s’",
localStore->printStorePath(step->drvPath),
machine->sshName);
replacement in src/hydra-queue-runner/build-remote.cc at line 283

[18.355]→[18.3446:3615](∅→∅),[18.895]→[18.3446:3615](∅→∅)

if (sendDerivation)
to << cmdBuildPaths << PathSet({step->drvPath});
else
to << cmdBuildDerivation << step->drvPath << basicDrv;

[18.355]

[18.3615]

if (sendDerivation) {
to << cmdBuildPaths;
writeStorePaths(*localStore, to, singleton(step->drvPath));
} else {
to << cmdBuildDerivation << localStore->printStorePath(step->drvPath);
writeDerivation(to, *localStore, basicDrv);
}
replacement in src/hydra-queue-runner/build-remote.cc at line 390

[18.6745]→[18.6745:6885](∅→∅)

printMsg(lvlInfo, format("outputs of ‘%1%’ substituted or already valid on ‘%2%’") % step->drvPath % machine->sshName);

[18.6745]

[18.6885]

printMsg(lvlInfo, "outputs of ‘%s’ substituted or already valid on ‘%s’",
localStore->printStorePath(step->drvPath), machine->sshName);
replacement in src/hydra-queue-runner/build-remote.cc at line 406

[18.2001]→[18.7168:7301](∅→∅)

PathSet outputs;
for (auto & output : step->drv.outputs)
outputs.insert(output.second.path);

[18.2001]

[18.46]

auto outputs = step->drv->outputPaths();
replacement in src/hydra-queue-runner/build-remote.cc at line 410

[18.7393]→[18.7393:7441](∅→∅)

to << cmdQueryPathInfos << outputs;

[18.7393]

[18.7441]

to << cmdQueryPathInfos;
writeStorePaths(*localStore, to, outputs);
replacement in src/hydra-queue-runner/build-remote.cc at line 426

[18.104]→[18.7913:8075](∅→∅)

printMsg(lvlDebug, format("copying outputs of ‘%s’ from ‘%s’ (%d bytes)")
% step->drvPath % machine->sshName % totalNarSize);

[18.104]

[18.523]

printMsg(lvlDebug, "copying outputs of ‘%s’ from ‘%s’ (%d bytes)",
localStore->printStorePath(step->drvPath), machine->sshName, totalNarSize);
replacement in src/hydra-queue-runner/build-remote.cc at line 441

[18.8575]→[18.8575:8736](∅→∅)

printMsg(lvlError, format("warning: had to wait %d ms for %d memory tokens for %s")
% resMs % totalNarSize % step->drvPath);

[18.8575]

[18.217]

printMsg(lvlError, "warning: had to wait %d ms for %d memory tokens for %s",
resMs, totalNarSize, localStore->printStorePath(step->drvPath));
replacement in src/hydra-queue-runner/build-remote.cc at line 444

[18.218]→[18.8796:8846](∅→∅)

to << cmdExportPaths << 0 << outputs;

[18.218]

[18.8846]

to << cmdExportPaths << 0;
writeStorePaths(*localStore, to, outputs);
replacement in src/hydra-queue-runner/build-result.cc at line 17

[18.666]→[18.666:790](∅→∅)

PathSet outputs;
for (auto & output : drv.outputs)
outputs.insert(output.second.path);
PathSet closure;

[18.666]

[18.790]

auto outputs = drv.outputPaths();
StorePathSet closure;
replacement in src/hydra-queue-runner/build-result.cc at line 20

[18.824]→[18.494:544](∅→∅)

store->computeFSClosure(output, closure);

[18.824]

[18.875]

store->computeFSClosure(singleton(output), closure);
replacement in src/hydra-queue-runner/build-result.cc at line 24

[18.42]→[18.42:118](∅→∅)

if (outputs.find(path) != outputs.end()) res.size += info->narSize;

[18.42]

[18.1073]

if (outputs.count(path)) res.size += info->narSize;
replacement in src/hydra-queue-runner/build-result.cc at line 40

[18.1182]→[18.0:58](∅→∅)

Path failedFile = output + "/nix-support/failed";

[18.1182]

[18.142]

auto outputS = store->printStorePath(output);

Path failedFile = outputS + "/nix-support/failed";
replacement in src/hydra-queue-runner/build-result.cc at line 46

[18.114]→[18.249:323](∅→∅)

Path productsFile = output + "/nix-support/hydra-build-products";

[18.114]

[18.323]

Path productsFile = outputS + "/nix-support/hydra-build-products";
replacement in src/hydra-queue-runner/build-result.cc at line 75

[18.2629]→[18.2629:2712](∅→∅)

product.name = product.path == output ? "" : baseNameOf(product.path);

[18.2629]

[18.2876]

product.name = product.path == store->printStorePath(output) ? "" : baseNameOf(product.path);
replacement in src/hydra-queue-runner/build-result.cc at line 94

[18.3446]→[18.3446:3493](∅→∅)

product.path = output.second.path;

[18.3446]

[18.3493]

product.path = store->printStorePath(output.second.path);
replacement in src/hydra-queue-runner/build-result.cc at line 97

[18.3606]→[18.3606:3664](∅→∅)

product.name = storePathToName(product.path);

[18.3606]

[18.3664]

product.name = output.second.path.name();
replacement in src/hydra-queue-runner/build-result.cc at line 101

[18.1292]→[18.1292:1375](∅→∅)

throw Error(format("getting status of ‘%1%’") % product.path);

[18.1292]

[18.1375]

throw Error("getting status of ‘%s’", product.path);
replacement in src/hydra-queue-runner/build-result.cc at line 109

[18.4043]→[18.4043:4104](∅→∅)

Path p = output + "/nix-support/hydra-release-name";

[18.4043]

[18.1433]

auto p = store->printStorePath(output) + "/nix-support/hydra-release-name";
replacement in src/hydra-queue-runner/build-result.cc at line 119

[18.664]→[18.1570:1636](∅→∅)

Path metricsFile = output + "/nix-support/hydra-metrics";

[18.664]

[18.1636]

auto metricsFile = store->printStorePath(output) + "/nix-support/hydra-metrics";
replacement in src/hydra-queue-runner/builder.cc at line 21

[18.327]→[8.149:217](∅→∅)

setThreadName("bld~" + baseNameOf(reservation->step->drvPath));

[18.327]

[8.217]

setThreadName("bld~" + std::string(reservation->step->drvPath.to_string()));
replacement in src/hydra-queue-runner/builder.cc at line 42

[6.474]→[6.474:661](∅→∅)

printMsg(lvlError, format("uncaught exception building ‘%1%’ on ‘%2%’: %3%")
% reservation->step->drvPath % reservation->machine->sshName % e.what());

[6.474]

[6.661]

printMsg(lvlError, "uncaught exception building ‘%s’ on ‘%s’: %s",
localStore->printStorePath(reservation->step->drvPath),
reservation->machine->sshName,
e.what());
replacement in src/hydra-queue-runner/builder.cc at line 65

[4.228]→[18.1241:1339](∅→∅),[18.1212]→[18.1241:1339](∅→∅),[18.1241]→[18.1241:1339](∅→∅)

printMsg(lvlInfo, format("will retry ‘%1%’ after %2%s") % step->drvPath % delta);

[4.228]

[18.1339]

printMsg(lvlInfo, "will retry ‘%s’ after %ss", localStore->printStorePath(step->drvPath), delta);
replacement in src/hydra-queue-runner/builder.cc at line 100

[18.484]→[18.484:507](∅→∅)

Path buildDrvPath;

[18.484]

[18.507]

std::optional<StorePath> buildDrvPath;
replacement in src/hydra-queue-runner/builder.cc at line 121

[18.2916]→[18.2916:3012](∅→∅)

printMsg(lvlInfo, format("maybe cancelling build step ‘%1%’") % step->drvPath);

[18.2916]

[18.232]

printMsg(lvlInfo, "maybe cancelling build step ‘%s’", localStore->printStorePath(step->drvPath));
replacement in src/hydra-queue-runner/builder.cc at line 143

[18.611]→[18.611:650](∅→∅)

buildDrvPath = build->drvPath;

[18.611]

[18.650]

buildDrvPath = build->drvPath.clone();
replacement in src/hydra-queue-runner/builder.cc at line 148

[18.840]→[18.840:933](∅→∅)

step->drvPath, repeats + 1, machine->sshName, buildId, (dependents.size() - 1));

[18.840]

[18.3414]

localStore->printStorePath(step->drvPath), repeats + 1, machine->sshName, buildId, (dependents.size() - 1));
replacement in src/hydra-queue-runner/builder.cc at line 151

[18.3421]→[18.828:898](∅→∅)

bool quit = buildId == buildOne && step->drvPath == buildDrvPath;

[18.3421]

[18.3460]

bool quit = buildId == buildOne && step->drvPath == *buildDrvPath;
replacement in src/hydra-queue-runner/builder.cc at line 171

[18.335]→[7.0:130](∅→∅)

store->upsertFile("log/" + baseNameOf(step->drvPath), readFile(result.logFile), "text/plain; charset=utf-8");

[18.335]

[18.449]

store->upsertFile("log/" + std::string(step->drvPath.to_string()), readFile(result.logFile), "text/plain; charset=utf-8");
replacement in src/hydra-queue-runner/builder.cc at line 223

[18.801]→[18.351:441](∅→∅),[18.2593]→[18.351:441](∅→∅),[18.351]→[18.351:441](∅→∅)

res = getBuildOutput(destStore, ref<FSAccessor>(result.accessor), step->drv);

[18.801]

[18.802]

res = getBuildOutput(destStore, ref<FSAccessor>(result.accessor), *step->drv);
replacement in src/hydra-queue-runner/builder.cc at line 260

[18.2621]→[18.5179:5347](∅→∅),[18.5179]→[18.5179:5347](∅→∅)

printMsg(lvlError, format("possibly transient failure building ‘%1%’ on ‘%2%’: %3%")
% step->drvPath % machine->sshName % result.errorMsg);

[18.2621]

[18.87]

printMsg(lvlError, "possibly transient failure building ‘%s’ on ‘%s’: %s",
localStore->printStorePath(step->drvPath), machine->sshName, result.errorMsg);
replacement in src/hydra-queue-runner/builder.cc at line 280

[18.5815]→[18.0:52](∅→∅)

for (auto & path : step->drv.outputPaths())

[18.5815]

[12.0]

for (auto & path : step->drv->outputPaths())
replacement in src/hydra-queue-runner/builder.cc at line 313

[18.7082]→[18.7082:7180](∅→∅)

printMsg(lvlDebug, format("finishing build step ‘%1%’") % step->drvPath);

[18.7082]

[18.7180]

printMsg(lvlDebug, "finishing build step ‘%s’",
localStore->printStorePath(step->drvPath));
replacement in src/hydra-queue-runner/builder.cc at line 399

[18.10074]→[18.10074:10173](∅→∅)

printMsg(lvlDebug, format("finishing build step ‘%1%’") % s->drvPath);

[18.10074]

[18.10173]

printMsg(lvlDebug, "finishing build step ‘%s’",
localStore->printStorePath(s->drvPath));
replacement in src/hydra-queue-runner/builder.cc at line 444

[18.3818]→[18.695:759](∅→∅),[18.13251]→[18.695:759](∅→∅),[18.759]→[18.13314:13409](∅→∅),[18.13314]→[18.13314:13409](∅→∅)

for (auto & path : step->drv.outputPaths())
txn.parameterized("insert into FailedPaths values ($1)")(path).exec();

[18.3818]

[18.13409]

for (auto & path : step->drv->outputPaths())
txn.parameterized("insert into FailedPaths values ($1)")(localStore->printStorePath(path)).exec();
replacement in src/hydra-queue-runner/builder.cc at line 485

[12.30]→[12.30:74](∅→∅)

void State::addRoot(const Path & storePath)

[12.30]

[12.74]

void State::addRoot(const StorePath & storePath)
replacement in src/hydra-queue-runner/builder.cc at line 487

[12.76]→[12.76:132](∅→∅)

auto root = rootsDir + "/" + baseNameOf(storePath);

[12.76]

[12.132]

auto root = rootsDir + "/" + std::string(storePath.to_string());
replacement in src/hydra-queue-runner/dispatcher.cc at line 13

[18.14756]→[18.14756:14839](∅→∅)

printMsg(lvlChatty, format("step ‘%1%’ is now runnable") % step->drvPath);

[18.14756]

[18.14839]

printMsg(lvlChatty, "step ‘%s’ is now runnable", localStore->printStorePath(step->drvPath));
replacement in src/hydra-queue-runner/dispatcher.cc at line 251

[14.143]→[14.143:224](∅→∅)

mi.machine->sshName, step->drvPath, step->drv.platform);

[14.143]

[14.224]

mi.machine->sshName, localStore->printStorePath(step->drvPath), step->drv->platform);
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 41

[11.51]→[11.51:91](∅→∅)

char * value = getenv(key.c_str());

[11.51]

[11.91]

auto value = getEnv(key);
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 43

[11.165]→[11.165:183](∅→∅)

return value;

[11.165]

[11.183]

return *value;
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 163

[18.171]→[18.171:275](∅→∅)

getEnv("NIX_REMOTE_SYSTEMS", pathExists(defaultMachinesFile) ? defaultMachinesFile : ""), ":");

[18.171]

[18.275]

getEnv("NIX_REMOTE_SYSTEMS").value_or(pathExists(defaultMachinesFile) ? defaultMachinesFile : ""), ":");
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 255

[18.446]→[18.446:470](∅→∅)

(step->drvPath)

[18.446]

[18.560]

(localStore->printStorePath(step->drvPath))
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 258

[18.109]→[18.109:138](∅→∅)

(step->drv.platform)

[18.109]

[18.596]

(step->drv->platform)
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 267

[18.8997]→[18.8997:9041](∅→∅)

for (auto & output : step->drv.outputs)

[18.8997]

[18.9041]

for (auto & output : step->drv->outputs)
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 270

[18.9164]→[18.2982:3054](∅→∅)

(buildId)(stepNr)(output.first)(output.second.path).exec();

[18.9164]

[18.9238]

(buildId)(stepNr)(output.first)(localStore->printStorePath(output.second.path)).exec();
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 313

[18.594]→[18.594:689](∅→∅)

Build::ptr build, const Path & drvPath, const string & outputName, const Path & storePath)

[18.594]

[18.689]

Build::ptr build, const StorePath & drvPath, const string & outputName, const StorePath & storePath)
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 323

[18.968]→[18.968:986](∅→∅)

(drvPath)

[18.968]

[18.986]

(localStore->printStorePath(drvPath))
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 333

[18.1173]→[18.1173:1232](∅→∅)

(build->id)(stepNr)(outputName)(storePath).exec();

[18.1173]

[18.1232]

(build->id)
(stepNr)
(outputName)
(localStore->printStorePath(storePath)).exec();
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 456

[18.1390]→[18.760:808](∅→∅),[18.808]→[18.1437:1535](∅→∅),[18.1437]→[18.1437:1535](∅→∅)

for (auto & path : step->drv.outputPaths())
if (!txn.parameterized("select 1 from FailedPaths where path = $1")(path).exec().empty())

[18.1390]

[18.1535]

for (auto & path : step->drv->outputPaths())
if (!txn.parameterized("select 1 from FailedPaths where path = $1")(localStore->printStorePath(path)).exec().empty())
replacement in src/hydra-queue-runner/hydra-queue-runner.cc at line 769

[10.75]→[18.74:137](∅→∅),[18.74]→[18.74:137](∅→∅)

localStore = openStore(getEnv("NIX_REMOTE"), localParams);

[10.75]

[18.299]

localStore = openStore(getEnv("NIX_REMOTE").value_or(""), localParams);
replacement in src/hydra-queue-runner/queue-monitor.cc at line 86

[18.82]→[18.82:132](∅→∅)

std::multimap<Path, BuildID> newBuildsByPath;

[18.82]

[18.312]

std::multimap<StorePath, BuildID> newBuildsByPath;
replacement in src/hydra-queue-runner/queue-monitor.cc at line 107

[18.22471]→[18.22471:22529](∅→∅)

build->drvPath = row["drvPath"].as<string>();

[18.22471]

[18.2019]

build->drvPath = localStore->parseStorePath(row["drvPath"].as<string>());
replacement in src/hydra-queue-runner/queue-monitor.cc at line 120

[18.474]→[18.474:547](∅→∅)

newBuildsByPath.emplace(std::make_pair(build->drvPath, id));

[18.474]

[18.22852]

newBuildsByPath.emplace(std::make_pair(build->drvPath.clone(), id));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 127

[18.22981]→[3.0:33](∅→∅)

std::set<Path> finishedDrvs;

[18.22981]

[18.22981]

std::set<StorePath> finishedDrvs;
replacement in src/hydra-queue-runner/queue-monitor.cc at line 163

[18.514]→[18.514:639](∅→∅)

printMsg(lvlError, format("marking build %d as cached failure due to ‘%s’") % build->id % ex.step->drvPath);

[18.514]

[18.639]

printMsg(lvlError, "marking build %d as cached failure due to ‘%s’",
build->id, localStore->printStorePath(ex.step->drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 175

[18.1105]→[18.1105:1152](∅→∅)

(ex.step->drvPath).exec();

[18.1105]

[18.1152]

(localStore->printStorePath(ex.step->drvPath)).exec();
replacement in src/hydra-queue-runner/queue-monitor.cc at line 179

[18.1276]→[18.1276:1341](∅→∅)

for (auto & output : ex.step->drv.outputs) {

[18.1276]

[18.1341]

for (auto & output : ex.step->drv->outputs) {
replacement in src/hydra-queue-runner/queue-monitor.cc at line 182

[18.1577]→[18.1577:1634](∅→∅)

(output.second.path).exec();

[18.1577]

[18.1634]

(localStore->printStorePath(output.second.path)).exec();
replacement in src/hydra-queue-runner/queue-monitor.cc at line 221

[18.24863]→[18.24863:24924](∅→∅)

Derivation drv = readDerivation(build->drvPath);

[18.24863]

[18.0]

Derivation drv = readDerivation(*localStore, localStore->printStorePath(build->drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 231

[18.25051]→[18.151:245](∅→∅)

printMsg(lvlInfo, format("marking build %1% as succeeded (cached)") % build->id);

[18.25051]

[18.25051]

printMsg(lvlInfo, "marking build %1% as succeeded (cached)", build->id);
replacement in src/hydra-queue-runner/queue-monitor.cc at line 254

[18.27614]→[18.27614:27764](∅→∅)

printMsg(lvlChatty, format("added build %1% (top-level step %2%, %3% new steps)")
% build->id % step->drvPath % newSteps.size());

[18.27614]

[18.27764]

printMsg(lvlChatty, "added build %1% (top-level step %2%, %3% new steps)",
build->id, localStore->printStorePath(step->drvPath), newSteps.size());
replacement in src/hydra-queue-runner/queue-monitor.cc at line 275

[18.28224]→[18.28224:28298](∅→∅)

e.addPrefix(format("while loading build %1%: ") % build->id);

[18.28224]

[18.28298]

e.addPrefix(fmt("while loading build %1%: ", build->id));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 362

[18.1782]→[18.1782:1856](∅→∅)

activeStepState->pid, activeStep->step->drvPath);

[18.1782]

[18.1856]

activeStepState->pid,
localStore->printStorePath(activeStep->step->drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 366

[18.1998]→[18.1998:2071](∅→∅)

activeStep->step->drvPath, strerror(errno));

[18.1998]

[18.2071]

localStore->printStorePath(activeStep->step->drvPath),
strerror(errno));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 376

[18.949]→[18.1464:1527](∅→∅),[18.12870]→[18.1464:1527](∅→∅),[18.1464]→[18.1464:1527](∅→∅),[18.1527]→[18.29485:29572](∅→∅),[18.29485]→[18.29485:29572](∅→∅)

Connection & conn, Build::ptr build, const Path & drvPath,
Build::ptr referringBuild, Step::ptr referringStep, std::set<Path> & finishedDrvs,

[18.12870]

[18.29572]

Connection & conn, Build::ptr build, const StorePath & drvPath,
Build::ptr referringBuild, Step::ptr referringStep, std::set<StorePath> & finishedDrvs,
replacement in src/hydra-queue-runner/queue-monitor.cc at line 406

[18.30688]→[18.30688:30725](∅→∅)

step->drvPath = drvPath;

[18.30688]

[18.30725]

step->drvPath = drvPath.clone();
replacement in src/hydra-queue-runner/queue-monitor.cc at line 420

[18.31006]→[18.31006:31041](∅→∅)

(*steps_)[drvPath] = step;

[18.31006]

[18.31041]

steps_->insert_or_assign(drvPath.clone(), step);
replacement in src/hydra-queue-runner/queue-monitor.cc at line 425

[18.31078]→[18.31078:31156](∅→∅)

printMsg(lvlDebug, format("considering derivation ‘%1%’") % drvPath);

[18.31078]

[18.31156]

printMsg(lvlDebug, "considering derivation ‘%1%’", localStore->printStorePath(drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 431

[18.31403]→[18.31403:31444](∅→∅),[18.31444]→[15.140:218](∅→∅)

step->drv = readDerivation(drvPath);
step->parsedDrv = std::make_unique<ParsedDerivation>(drvPath, step->drv);

[18.31403]

[18.0]

step->drv = std::make_unique<Derivation>(readDerivation(*localStore, localStore->printStorePath(drvPath)));
step->parsedDrv = std::make_unique<ParsedDerivation>(drvPath.clone(), *step->drv);
replacement in src/hydra-queue-runner/queue-monitor.cc at line 435

[15.285]→[18.657:734](∅→∅),[18.1009]→[18.657:734](∅→∅)

step->isDeterministic = get(step->drv.env, "isDetermistic", "0") == "1";

[15.285]

[18.197]

step->isDeterministic = get(step->drv->env, "isDetermistic").value_or("0") == "1";
replacement in src/hydra-queue-runner/queue-monitor.cc at line 437

[18.198]→[18.296:339](∅→∅),[18.31444]→[18.296:339](∅→∅)

step->systemType = step->drv.platform;

[18.198]

[18.31444]

step->systemType = step->drv->platform;
replacement in src/hydra-queue-runner/queue-monitor.cc at line 439

[18.31450]→[18.31450:31513](∅→∅)

auto i = step->drv.env.find("requiredSystemFeatures");

[18.31450]

[18.199]

auto i = step->drv->env.find("requiredSystemFeatures");
replacement in src/hydra-queue-runner/queue-monitor.cc at line 441

[18.227]→[18.227:265](∅→∅)

if (i != step->drv.env.end())

[18.227]

[18.265]

if (i != step->drv->env.end())
replacement in src/hydra-queue-runner/queue-monitor.cc at line 457

[18.31904]→[18.1010:1057](∅→∅)

PathSet outputs = step->drv.outputPaths();

[18.31904]

[18.1574]

auto outputs = step->drv->outputPaths();
replacement in src/hydra-queue-runner/queue-monitor.cc at line 459

[18.1631]→[18.1631:1670](∅→∅)

for (auto & i : step->drv.outputs)

[18.1605]

[18.12871]

for (auto & i : step->drv->outputs)
replacement in src/hydra-queue-runner/queue-monitor.cc at line 462

[18.32022]→[18.1671:1712](∅→∅)

missing[i.first] = i.second;

[18.32022]

[18.573]

missing.insert_or_assign(i.first,
DerivationOutput(i.second.path.clone(), std::string(i.second.hashAlgo), std::string(i.second.hash)));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 476

[18.962]→[18.962:1043](∅→∅)

localStore->querySubstitutablePathInfos({i.second.path}, infos);

[18.962]

[18.1043]

localStore->querySubstitutablePathInfos(singleton(i.second.path), infos);
replacement in src/hydra-queue-runner/queue-monitor.cc at line 489

[18.1279]→[18.1279:1396](∅→∅)

printInfo("copying output ‘%1%’ of ‘%2%’ from local store", i.second.path, drvPath);

[18.1279]

[18.1396]

printInfo("copying output ‘%1%’ of ‘%2%’ from local store",
localStore->printStorePath(i.second.path),
localStore->printStorePath(drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 493

[18.1423]→[18.1423:1528](∅→∅)

printInfo("substituting output ‘%1%’ of ‘%2%’", i.second.path, drvPath);

[18.1423]

[18.1528]

printInfo("substituting output ‘%1%’ of ‘%2%’",
localStore->printStorePath(i.second.path),
localStore->printStorePath(drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 500

[18.1700]→[18.1700:1785](∅→∅)

copyClosure(ref<Store>(localStore), destStore, {i.second.path});

[18.1700]

[18.2442]

copyClosure(ref<Store>(localStore), destStore, singleton(i.second.path));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 512

[18.2872]→[18.1786:1914](∅→∅)

printError("while copying/substituting output ‘%s’ of ‘%s’: %s", i.second.path, drvPath, e.what());

[18.2872]

[18.2872]

printError("while copying/substituting output ‘%s’ of ‘%s’: %s",
localStore->printStorePath(i.second.path),
localStore->printStorePath(drvPath),
e.what());
replacement in src/hydra-queue-runner/queue-monitor.cc at line 525

[18.32140]→[18.32140:32178](∅→∅)

finishedDrvs.insert(drvPath);

[18.32140]

[18.32178]

finishedDrvs.insert(drvPath.clone());
replacement in src/hydra-queue-runner/queue-monitor.cc at line 530

[18.32235]→[18.32235:32310](∅→∅)

printMsg(lvlDebug, format("creating build step ‘%1%’") % drvPath);

[18.32235]

[18.32337]

printMsg(lvlDebug, "creating build step ‘%1%’", localStore->printStorePath(drvPath));
replacement in src/hydra-queue-runner/queue-monitor.cc at line 533

[18.32383]→[18.32383:32426](∅→∅)

for (auto & i : step->drv.inputDrvs) {

[18.32383]

[18.13064]

for (auto & i : step->drv->inputDrvs) {
replacement in src/hydra-queue-runner/queue-monitor.cc at line 621

[18.544]→[18.544:585](∅→∅)

(output.second.path).exec();

[18.544]

[18.585]

(localStore->printStorePath(output.second.path)).exec();
replacement in src/hydra-queue-runner/state.hh at line 126

[18.2067]→[18.285:354](∅→∅)

nix::Path drvPath;
std::map<std::string, nix::Path> outputs;

[18.2067]

[18.2389]

nix::StorePath drvPath;
std::map<std::string, nix::StorePath> outputs;
replacement in src/hydra-queue-runner/state.hh at line 153

[18.2373]→[18.355:403](∅→∅)

nix::Path drvPath;
nix::Derivation drv;

[18.2373]

[15.320]

nix::StorePath drvPath;
std::unique_ptr<nix::Derivation> drv;
replacement in src/hydra-queue-runner/state.hh at line 255

[18.86]→[13.0:113](∅→∅)

if (!systemTypes.count(step->drv.platform == "builtin" ? nix::settings.thisSystem : step->drv.platform))

[18.86]

[13.113]

if (!systemTypes.count(step->drv->platform == "builtin" ? nix::settings.thisSystem : step->drv->platform))
replacement in src/hydra-queue-runner/state.hh at line 316

[18.4741]→[18.474:525](∅→∅)

typedef std::map<nix::Path, Step::wptr> Steps;

[18.4741]

[18.1737]

typedef std::map<nix::StorePath, Step::wptr> Steps;
replacement in src/hydra-queue-runner/state.hh at line 457

[18.3221]→[18.3221:3336](∅→∅)

Build::ptr build, const nix::Path & drvPath, const std::string & outputName, const nix::Path & storePath);

[18.3221]

[18.7490]

Build::ptr build, const nix::StorePath & drvPath, const std::string & outputName, const nix::StorePath & storePath);
replacement in src/hydra-queue-runner/state.hh at line 476

[18.1213]→[18.3400:3472](∅→∅),[18.3400]→[18.3400:3472](∅→∅),[18.3472]→[18.966:1062](∅→∅),[18.966]→[18.966:1062](∅→∅)

Connection & conn, Build::ptr build, const nix::Path & drvPath,
Build::ptr referringBuild, Step::ptr referringStep, std::set<nix::Path> & finishedDrvs,

[18.1213]

[18.7956]

Connection & conn, Build::ptr build, const nix::StorePath & drvPath,
Build::ptr referringBuild, Step::ptr referringStep, std::set<nix::StorePath> & finishedDrvs,
replacement in src/hydra-queue-runner/state.hh at line 526

[12.302]→[12.302:349](∅→∅)

void addRoot(const nix::Path & storePath);

[12.302]

[18.9109]

void addRoot(const nix::StorePath & storePath);
replacement in src/hydra-queue-runner/token-server.hh at line 10

[18.1694]→[18.1945:1972](∅→∅)

MakeError(NoTokens, Error)

[18.1694]

[18.1972]

MakeError(NoTokens, Error);
replacement in src/libhydra/db.hh at line 15

[18.57]→[18.57:119](∅→∅)

auto s = getEnv("HYDRA_DBI", "dbi:Pg:dbname=hydra;");

[18.57]

[18.119]

auto s = getEnv("HYDRA_DBI").value_or("dbi:Pg:dbname=hydra;");
replacement in src/libhydra/hydra-config.hh at line 17

[18.639]→[18.639:682](∅→∅)

if (pathExists(hydraConfigFile)) {

[18.639]

[18.682]

if (hydraConfigFile && pathExists(*hydraConfigFile)) {
replacement in src/libhydra/hydra-config.hh at line 19

[18.683]→[18.683:772](∅→∅)

for (auto line : tokenizeString<Strings>(readFile(hydraConfigFile), "\n")) {

[18.683]

[18.772]

for (auto line : tokenizeString<Strings>(readFile(*hydraConfigFile), "\n")) {