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

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

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

    return sDone;
}

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. */

    std::vector<BuildID> dependentIDs;

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

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

            }
        }

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

            pqxx::work txn(conn);

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

            /* 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++;
            }

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

                nrBuildsDone++;

            /* 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();

            }

        stepFinished = true;

        /* 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;
        }
    }

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

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

        txn.exec_params0
            ("insert into BuildStepOutputs (build, stepnr, name, path) values ($1, $2, $3, $4)",

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

void State::dumpStatus(Connection & conn)

        root.attr("nrUnsupportedSteps", nrUnsupportedSteps);

        dumpStatus(*conn);

                conn->await_notification();
                dumpStatus(*conn);

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

    std::multimap<StorePath, BuildID> newBuildsByPath;

            auto build = std::make_shared<Build>(
                localStore->parseStorePath(row["drvPath"].as<string>()));

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

    std::set<StorePath> finishedDrvs;

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

                        auto res = txn.exec_params
                            ("select max(s.build) from BuildSteps s join BuildStepOutputs o on s.build = o.build where path = $1 and startTime != 0 and stopTime != 0 and status = 1",

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

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

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

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

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

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

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

            step = std::make_shared<Step>(drvPath.clone());

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

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

    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").value_or("0") == "1";

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

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

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

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

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

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

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

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

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

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

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

        finishedDrvs.insert(drvPath.clone());

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

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

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

                    for (auto & output : ex.step->drv->outputs) {
                    (localStore->printStorePath(ex.step->drvPath)).exec();

        @cmd = ("hydra-eval-jobs",
                "<" . $nixExprInputName . "/" . $nixExprPath . ">",
                "--gc-roots-dir", getGCRootsDir,
                "--max-jobs", 1,
                inputsToArgs($inputInfo));
    }