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

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

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

    std::optional<StorePath> buildDrvPath;

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

        buildDrvPath = build->drvPath.clone();

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

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

                    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);

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

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

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

    } else {

    } else
        failStep(*conn, step, buildId, result, machine, stepFinished, quit);

        /* Register failure in the database for all Build objects that
           directly or indirectly depend on this step. */

    // FIXME: keep stats about aborted steps?
    nrStepsDone++;
    totalStepTime += stepStopTime - stepStartTime;
    totalStepBuildTime += result.stopTime - result.startTime;
    machine->state->nrStepsDone++;
    machine->state->totalStepTime += stepStopTime - stepStartTime;
    machine->state->totalStepBuildTime += result.stopTime - result.startTime;

        std::vector<BuildID> dependentIDs;

    if (quit) exit(0); // testing hack; FIXME: this won't run plugins

        while (true) {
            /* Get the builds and steps that depend on this step. */
            std::set<Build::ptr> indirect;
            {
                auto steps_(steps.lock());
                std::set<Step::ptr> steps;
                getDependents(step, indirect, steps);

    return sDone;
}

                /* If there are no builds left, delete all referring
                   steps from ‘steps’. As for the success case, we can
                   be certain no new referrers can be added. */
                if (indirect.empty()) {
                    for (auto & s : steps) {
                        printMsg(lvlDebug, "finishing build step ‘%s’",
                            localStore->printStorePath(s->drvPath));
                        printMsg(lvlDebug, "finishing build step ‘%s’",
                            localStore->printStorePath(s->drvPath));
                        steps_->erase(s->drvPath);
                    }
                }
            }

            if (indirect.empty() && stepFinished) break;

void State::failStep(
    Connection & conn,
    Step::ptr step,
    BuildID buildId,
    const RemoteResult & result,
    Machine::ptr machine,
    bool & stepFinished,
    bool & quit)
{
    /* Register failure in the database for all Build objects that
       directly or indirectly depend on this step. */

            /* Update the database. */
            {
                auto mc = startDbUpdate();

    std::vector<BuildID> dependentIDs;

                pqxx::work txn(*conn);

    while (true) {
        /* Get the builds and steps that depend on this step. */
        std::set<Build::ptr> indirect;
        {
            auto steps_(steps.lock());
            std::set<Step::ptr> steps;
            getDependents(step, indirect, steps);

                /* Create failed build steps for every build that
                   depends on this, except when this step is cached
                   and is the top-level of that build (since then it's
                   redundant with the build's isCachedBuild field). */
                for (auto & build2 : indirect) {
                    if ((result.stepStatus == bsCachedFailure && build2->drvPath == step->drvPath) ||
                        (result.stepStatus != bsCachedFailure && buildId == build2->id) ||
                        build2->finishedInDB)
                        continue;
                    createBuildStep(txn, 0, build2->id, step, machine->sshName,
                        result.stepStatus, result.errorMsg, buildId == build2->id ? 0 : buildId);

            /* If there are no builds left, delete all referring
               steps from ‘steps’. As for the success case, we can
               be certain no new referrers can be added. */
            if (indirect.empty()) {
                for (auto & s : steps) {
                    printMsg(lvlDebug, "finishing build step ‘%s’",
                        localStore->printStorePath(s->drvPath));
                    steps_->erase(s->drvPath);

            }
        }

                /* Mark all builds that depend on this derivation as failed. */
                for (auto & build2 : indirect) {
                    if (build2->finishedInDB) continue;
                    printMsg(lvlError, format("marking build %1% as failed") % build2->id);
                    txn.parameterized
                        ("update Builds set finished = 1, buildStatus = $2, startTime = $3, stopTime = $4, isCachedBuild = $5, notificationPendingSince = $4 where id = $1 and finished = 0")
                        (build2->id)
                        ((int) (build2->drvPath != step->drvPath && result.buildStatus() == bsFailed ? bsDepFailed : result.buildStatus()))
                        (result.startTime)
                        (result.stopTime)
                        (result.stepStatus == bsCachedFailure ? 1 : 0).exec();
                    nrBuildsDone++;
                }

        if (indirect.empty() && stepFinished) break;
        /* Update the database. */
        {
            auto mc = startDbUpdate();

                /* Remember failed paths in the database so that they
                   won't be built again. */
                if (result.stepStatus != bsCachedFailure && result.canCache)
                    for (auto & path : step->drv->outputPaths())
                        txn.parameterized("insert into FailedPaths values ($1)")(localStore->printStorePath(path)).exec();
                    for (auto & path : step->drv->outputPaths())
                        txn.parameterized("insert into FailedPaths values ($1)")(localStore->printStorePath(path)).exec();

            pqxx::work txn(conn);

                txn.commit();

            /* Create failed build steps for every build that
               depends on this, except when this step is cached
               and is the top-level of that build (since then it's
               redundant with the build's isCachedBuild field). */
            for (auto & build : indirect) {
                if ((result.stepStatus == bsCachedFailure && build->drvPath == step->drvPath) ||
                    ((result.stepStatus != bsCachedFailure && result.stepStatus != bsUnsupported) && buildId == build->id) ||
                    build->finishedInDB)
                    continue;
                createBuildStep(txn,
                    0, build->id, step, machine ? machine->sshName : "",
                    result.stepStatus, result.errorMsg, buildId == build->id ? 0 : buildId);

            stepFinished = true;

            /* Mark all builds that depend on this derivation as failed. */
            for (auto & build : indirect) {
                if (build->finishedInDB) continue;
                printMsg(lvlError, format("marking build %1% as failed") % build->id);
                txn.parameterized
                    ("update Builds set finished = 1, buildStatus = $2, startTime = $3, stopTime = $4, isCachedBuild = $5, notificationPendingSince = $4 where id = $1 and finished = 0")
                    (build->id)
                    ((int) (build->drvPath != step->drvPath && result.buildStatus() == bsFailed ? bsDepFailed : result.buildStatus()))
                    (result.startTime)
                    (result.stopTime)
                    (result.stepStatus == bsCachedFailure ? 1 : 0).exec();
                nrBuildsDone++;
            }

            /* Remove the indirect dependencies from ‘builds’. This
               will cause them to be destroyed. */
            for (auto & b : indirect) {
                auto builds_(builds.lock());
                b->finishedInDB = true;
                builds_->erase(b->id);
                dependentIDs.push_back(b->id);
                if (buildOne == b->id) quit = true;
            }
        }

            /* Remember failed paths in the database so that they
               won't be built again. */
            if (result.stepStatus != bsCachedFailure && result.canCache)
                for (auto & path : step->drv->outputPaths())
                    txn.parameterized("insert into FailedPaths values ($1)")(localStore->printStorePath(path)).exec();

        /* Send notification about this build and its dependents. */
        {
            pqxx::work txn(*conn);
            notifyBuildFinished(txn, buildId, dependentIDs);

    }

    // FIXME: keep stats about aborted steps?
    nrStepsDone++;
    totalStepTime += stepStopTime - stepStartTime;
    totalStepBuildTime += result.stopTime - result.startTime;
    machine->state->nrStepsDone++;
    machine->state->totalStepTime += stepStopTime - stepStartTime;
    machine->state->totalStepBuildTime += result.stopTime - result.startTime;

        stepFinished = true;

    if (quit) exit(0); // testing hack; FIXME: this won't run plugins

        /* Remove the indirect dependencies from ‘builds’. This
           will cause them to be destroyed. */
        for (auto & b : indirect) {
            auto builds_(builds.lock());
            b->finishedInDB = true;
            builds_->erase(b->id);
            dependentIDs.push_back(b->id);
            if (buildOne == b->id) quit = true;
        }
    }

    return sDone;

    /* Send notification about this build and its dependents. */
    {
        pqxx::work txn(conn);
        notifyBuildFinished(txn, buildId, dependentIDs);
        txn.commit();
    }

void State::addRoot(const StorePath & storePath)

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

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

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

    abortUnsupported();

void State::abortUnsupported()
{
    /* Make a copy of 'runnable' and 'machines' so we don't block them
       very long. */
    auto runnable2 = *runnable.lock();
    auto machines2 = *machines.lock();
    system_time now = std::chrono::system_clock::now();
    auto now2 = time(0);

    std::unordered_set<Step::ptr> aborted;

    for (auto & wstep : runnable2) {
        auto step(wstep.lock());
        if (!step) continue;
        bool supported = false;
        for (auto & machine : machines2) {
            if (machine.second->supportsStep(step)) {
                step->state.lock()->lastSupported = now;
                supported = true;
                break;
            }
        }
        if (!supported
            && std::chrono::duration_cast<std::chrono::seconds>(now - step->state.lock()->lastSupported).count() >= maxUnsupportedTime)
        {
            printError("aborting unsupported build step '%s' (type '%s')",
                localStore->printStorePath(step->drvPath),
                step->systemType);
            aborted.insert(step);
            auto conn(dbPool.get());
            std::set<Build::ptr> dependents;
            std::set<Step::ptr> steps;
            getDependents(step, dependents, steps);
            /* Maybe the step got cancelled. */
            if (dependents.empty()) continue;
            /* Find the build that has this step as the top-level (if
               any). */
            Build::ptr build;
            for (auto build2 : dependents) {
                if (build2->drvPath == step->drvPath)
                    build = build2;
            }
            if (!build) build = *dependents.begin();
            bool stepFinished = false;
            bool quit = false;
            failStep(
                *conn, step, build->id,
                RemoteResult {
                    .stepStatus = bsUnsupported,
                    .errorMsg = fmt("unsupported system type '%s'",
                        step->systemType),
                    .startTime = now2,
                    .stopTime = now2,
                },
                nullptr, stepFinished, quit);
            if (quit) exit(1);
        }
    }
    /* Clean up 'runnable'. */
    {
        auto runnable_(runnable.lock());
        for (auto i = runnable_->begin(); i != runnable_->end(); ) {
            if (aborted.count(i->lock()))
                i = runnable_->erase(i);
            else
                ++i;
        }
    }
}

    auto value = getEnv(key);

    return *value;

    , maxUnsupportedTime(config->getIntOption("max_unsupported_time", 0))

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

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

        (step->drv->platform)

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

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

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

        (localStore->printStorePath(drvPath))

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

    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").value_or(""), localParams);

    BuildStatus buildStatus()

    BuildStatus buildStatus() const

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

    Build(nix::StorePath && drvPath) : drvPath(std::move(drvPath))
    { }

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

        /* The time that we last saw a machine that supports this
           step. */
        system_time lastSupported = std::chrono::system_clock::now();

    Step(nix::StorePath && drvPath) : drvPath(std::move(drvPath))
    { }

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

    /* Time in seconds before unsupported build steps are aborted. */
    const unsigned int maxUnsupportedTime = 0;

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

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

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

    void failStep(
        Connection & conn,
        Step::ptr step,
        BuildID buildId,
        const RemoteResult & result,
        Machine::ptr machine,
        bool & stepFinished,
        bool & quit);

    void abortUnsupported();

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