hydra_eval_jobs_LDADD = $(NIX_LIBS)

hydra_eval_jobs_LDADD = $(NIX_LIBS) -lnixrust

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

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

hydra_queue_runner_LDADD = $(NIX_LIBS) -lpqxx

hydra_queue_runner_LDADD = $(NIX_LIBS) -lpqxx -lnixrust

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

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

    PathSet closure;

    StorePathSet closure;

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

    to << cmdQueryValidPaths << 1 << useSubstitutes;
    writeStorePaths(*destStore, to, closure);

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

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

    Paths sorted = destStore->topoSortPaths(closure);

    auto sorted = destStore->topoSortPaths(closure);

    Paths missing;

    StorePathSet missing;

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

        if (!present.count(*i)) missing.insert(i->clone());

    string base = baseNameOf(step->drvPath);

    string base(step->drvPath.to_string());

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

        StorePathSet inputs;
        BasicDerivation basicDrv(*step->drv);

            inputs.insert(step->drvPath);

            inputs.insert(step->drvPath.clone());

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

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

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

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

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

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

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

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

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

            printMsg(lvlDebug, "sending closure of ‘%s’ to ‘%s’",
                localStore->printStorePath(step->drvPath), machine->sshName);

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

        printMsg(lvlDebug, "building ‘%s’ on ‘%s’",
            localStore->printStorePath(step->drvPath),
            machine->sshName);

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

        if (sendDerivation) {
            to << cmdBuildPaths;
            writeStorePaths(*localStore, to, singleton(step->drvPath));
        } else {
            to << cmdBuildDerivation << localStore->printStorePath(step->drvPath);
            writeDerivation(to, *localStore, basicDrv);
        }

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

            printMsg(lvlInfo, "outputs of ‘%s’ substituted or already valid on ‘%s’",
                localStore->printStorePath(step->drvPath), machine->sshName);

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

            auto outputs = step->drv->outputPaths();

            to << cmdQueryPathInfos << outputs;

            to << cmdQueryPathInfos;
            writeStorePaths(*localStore, to, outputs);

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

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

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

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

            to << cmdExportPaths << 0 << outputs;

            to << cmdExportPaths << 0;
            writeStorePaths(*localStore, to, outputs);

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

    auto outputs = drv.outputPaths();
    StorePathSet closure;

        store->computeFSClosure(output, closure);

        store->computeFSClosure(singleton(output), closure);

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

        if (outputs.count(path)) res.size += info->narSize;

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

        auto outputS = store->printStorePath(output);
        Path failedFile = outputS + "/nix-support/failed";

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

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

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

            product.name = product.path == store->printStorePath(output) ? "" : baseNameOf(product.path);

            product.path = output.second.path;

            product.path = store->printStorePath(output.second.path);

            product.name = storePathToName(product.path);

            product.name = output.second.path.name();

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

                throw Error("getting status of ‘%s’", product.path);

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

        auto p = store->printStorePath(output) + "/nix-support/hydra-release-name";

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

        auto metricsFile = store->printStorePath(output) + "/nix-support/hydra-metrics";

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

    setThreadName("bld~" + std::string(reservation->step->drvPath.to_string()));

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

            printMsg(lvlError, "uncaught exception building ‘%s’ on ‘%s’: %s",
                localStore->printStorePath(reservation->step->drvPath),
                reservation->machine->sshName,
                e.what());

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

            printMsg(lvlInfo, "will retry ‘%s’ after %ss", localStore->printStorePath(step->drvPath), delta);

    Path buildDrvPath;

    std::optional<StorePath> buildDrvPath;

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

            printMsg(lvlInfo, "maybe cancelling build step ‘%s’", localStore->printStorePath(step->drvPath));

        buildDrvPath = build->drvPath;

        buildDrvPath = build->drvPath.clone();

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

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

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

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

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

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

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

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

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

        printMsg(lvlError, "possibly transient failure building ‘%s’ on ‘%s’: %s",
            localStore->printStorePath(step->drvPath), machine->sshName, result.errorMsg);

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

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

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

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

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

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

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

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

void State::addRoot(const Path & storePath)

void State::addRoot(const StorePath & storePath)

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

    auto root = rootsDir + "/" + std::string(storePath.to_string());

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

    printMsg(lvlChatty, "step ‘%s’ is now runnable", localStore->printStorePath(step->drvPath));

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

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

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

    auto value = getEnv(key);

    return value;

    return *value;

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

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

        (step->drvPath)

        (localStore->printStorePath(step->drvPath))

        (step->drv.platform)

        (step->drv->platform)

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

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

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

            (buildId)(stepNr)(output.first)(localStore->printStorePath(output.second.path)).exec();

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

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

        (drvPath)

        (localStore->printStorePath(drvPath))

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

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

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

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

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

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

    std::multimap<Path, BuildID> newBuildsByPath;

    std::multimap<StorePath, BuildID> newBuildsByPath;

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

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

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

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

    std::set<Path> finishedDrvs;

    std::set<StorePath> finishedDrvs;

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

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

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

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

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

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

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

                            (localStore->printStorePath(output.second.path)).exec();

            Derivation drv = readDerivation(build->drvPath);

            Derivation drv = readDerivation(*localStore, localStore->printStorePath(build->drvPath));

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

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

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

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

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

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

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

                        activeStepState->pid,
                        localStore->printStorePath(activeStep->step->drvPath));

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

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

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

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

            step->drvPath = drvPath;

            step->drvPath = drvPath.clone();

        (*steps_)[drvPath] = step;

        steps_->insert_or_assign(drvPath.clone(), step);

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

    printMsg(lvlDebug, "considering derivation ‘%1%’", localStore->printStorePath(drvPath));

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

    step->drv = std::make_unique<Derivation>(readDerivation(*localStore, localStore->printStorePath(drvPath)));
    step->parsedDrv = std::make_unique<ParsedDerivation>(drvPath.clone(), *step->drv);

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

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

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

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

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

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

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

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

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

    auto outputs = step->drv->outputPaths();

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

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

            missing[i.first] = i.second;

            missing.insert_or_assign(i.first,
                DerivationOutput(i.second.path.clone(), std::string(i.second.hashAlgo), std::string(i.second.hash)));

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

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

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

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

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

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

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

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

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

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

        finishedDrvs.insert(drvPath);

        finishedDrvs.insert(drvPath.clone());

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

    printMsg(lvlDebug, "creating build step ‘%1%’", localStore->printStorePath(drvPath));

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

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

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

            (localStore->printStorePath(output.second.path)).exec();

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

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

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

    nix::StorePath drvPath;
    std::unique_ptr<nix::Derivation> drv;

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

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

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

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

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

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

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

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

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

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

MakeError(NoTokens, Error)

MakeError(NoTokens, Error);

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

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

        if (pathExists(hydraConfigFile)) {

        if (hydraConfigFile && pathExists(*hydraConfigFile)) {

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

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