printMsg(lvlError, format("sending %1% missing paths") % missing.size());

    printMsg(lvlDebug, format("sending %1% missing paths") % missing.size());

    writeInt(SERVE_MAGIC_1, to);
    writeInt(SERVE_PROTOCOL_VERSION, to);
    to.flush();

    try {
        writeInt(SERVE_MAGIC_1, to);
        writeInt(SERVE_PROTOCOL_VERSION, to);
        to.flush();

    unsigned int magic = readInt(from);
    if (magic != SERVE_MAGIC_2)
        throw Error(format("protocol mismatch with ‘nix-store --serve’ on ‘%1%’") % sshName);
    unsigned int version = readInt(from);
    if (GET_PROTOCOL_MAJOR(version) != 0x200)
        throw Error(format("unsupported ‘nix-store --serve’ protocol version on ‘%1%’") % sshName);

        unsigned int magic = readInt(from);
        if (magic != SERVE_MAGIC_2)
            throw Error(format("protocol mismatch with ‘nix-store --serve’ on ‘%1%’") % sshName);
        unsigned int version = readInt(from);
        if (GET_PROTOCOL_MAJOR(version) != 0x200)
            throw Error(format("unsupported ‘nix-store --serve’ protocol version on ‘%1%’") % sshName);
    } catch (EndOfFile & e) {
        child.pid.wait(true);
        throw Error(format("cannot connect to ‘%1%’: %2%") % sshName % chomp(readFile(logFile)));
    }

    printMsg(lvlError, format("sending closure of ‘%1%’ to ‘%2%’") % drvPath % sshName);

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

    printMsg(lvlError, format("building ‘%1%’ on ‘%2%’") % drvPath % sshName);

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

    printMsg(lvlError, format("copying outputs of ‘%1%’ from ‘%2%’") % drvPath % sshName);

    printMsg(lvlDebug, format("copying outputs of ‘%1%’ from ‘%2%’") % drvPath % sshName);

#include <cmath>
#include <chrono>

const int maxTries = 5;
const int retryInterval = 60; // seconds
const float retryBackoff = 3.0;

typedef std::chrono::time_point<std::chrono::system_clock> system_time;

        /* Number of times we've tried this step. */
        unsigned int tries = 0;
        /* Point in time after which the step can be retried. */
        system_time after;

    ~Step()
    {
        printMsg(lvlDebug, format("destroying step %1%") % drvPath);
    }

    ~Step() { }

    std::atomic<int> nrQueueWakeups;

    std::atomic<unsigned int> nrRetries;
    std::atomic<unsigned int> maxNrRetries;
    std::atomic<unsigned int> nrQueueWakeups;
    std::atomic<unsigned int> nrDispatcherWakeups;

    void doBuildStep(std::shared_ptr<StoreAPI> store, Step::ptr step,

    /* Perform the given build step. Return true if the step is to be
       retried. */
    bool doBuildStep(std::shared_ptr<StoreAPI> store, Step::ptr step,

    nrQueueWakeups = 0;

    nrRetries = maxNrRetries = nrQueueWakeups = nrDispatcherWakeups = 0;

        auto sleepUntil = system_time::max();

            system_time now = std::chrono::system_clock::now();

                }
                /* Skip previously failed steps that aren't ready to
                   be retried. */
                {
                    auto step_(step->state.lock());
                    if (step_->tries > 0 && step_->after > now) {
                        if (step_->after < sleepUntil)
                            sleepUntil = step_->after;
                        ++i;
                        continue;
                    }

            dispatcherWakeup.wait(lock);

            printMsg(lvlDebug, format("dispatcher sleeping for %1%s") %
                std::chrono::duration_cast<std::chrono::seconds>(sleepUntil - std::chrono::system_clock::now()).count());
            dispatcherWakeup.wait_until(lock, sleepUntil);
            nrDispatcherWakeups++;

    bool retry = true;

        doBuildStep(store, step, reservation->machine);

        retry = doBuildStep(store, step, reservation->machine);

        printMsg(lvlError, format("error building ‘%1%’: %2%") % step->drvPath % e.what());
        // FIXME: put step back in runnable and retry

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

    /* If there was a temporary failure, retry the step after an
       exponentially increasing interval. */
    if (retry) {
        {
            auto step_(step->state.lock());
            step_->tries++;
            nrRetries++;
            if (step_->tries > maxNrRetries) maxNrRetries = step_->tries; // yeah yeah, not atomic
            int delta = retryInterval * powf(retryBackoff, step_->tries - 1);
            printMsg(lvlInfo, format("will retry ‘%1%’ after %2%s") % step->drvPath % delta);
            step_->after = std::chrono::system_clock::now() + std::chrono::seconds(delta);
        }
        makeRunnable(step);
    }

void State::doBuildStep(std::shared_ptr<StoreAPI> store, Step::ptr step,

bool State::doBuildStep(std::shared_ptr<StoreAPI> store, Step::ptr step,

               are gone (e.g. cancelled). So don't bother. (This is

               are gone (e.g. cancelled). So don't bother. This is

               Build). FIXME: what if a new Build gets a reference to
               this step? */

               Build. However, it's possible that a new Build just
               created a reference to this step. So to handle that
               possibility, we retry this step (putting it back in
               the runnable queue). If there are really no strong
               pointers to the step, it will be deleted. */

            destroyStep(step, false);
            return;

            return true;

    /* If any of the outputs have previously failed, then don't
       retry. */

    /* If any of the outputs have previously failed, then don't bother
       building again. */

            printMsg(lvlError, format("ERROR: %1%") % e.msg());
            abort(); // FIXME

            printMsg(lvlError, format("irregular failure building ‘%1%’ on ‘%2%’: %3%")
                % step->drvPath % machine->sshName % e.msg());

    bool retry = false;
    if (result.status == RemoteResult::rrMiscFailure) {
        auto step_(step->state.lock());
        retry = step_->tries + 1 < maxTries;
    }

    {

    if (!retry) {

            BuildStatus buildStatus =
                result.status == RemoteResult::rrPermanentFailure ? bsFailed : bsAborted;
            BuildStepStatus buildStepStatus =
                result.status == RemoteResult::rrPermanentFailure ? bssFailed : bssAborted;

            if (result.status != RemoteResult::rrMiscFailure) result.errorMsg = "";

            if (buildStatus != bsAborted) result.errorMsg = "";

            if (!cachedFailure) {

            if (!cachedFailure && !retry) {

                    createBuildStep(txn, 0, build2, step, machine->sshName, bssFailed, result.errorMsg, build->id);

                    createBuildStep(txn, 0, build2, step, machine->sshName,
                        buildStepStatus, result.errorMsg, build->id);

                finishBuildStep(txn, result.startTime, result.stopTime, build->id, stepNr, machine->sshName, bssFailed, result.errorMsg);

            if (!cachedFailure)
                finishBuildStep(txn, result.startTime, result.stopTime, build->id,
                    stepNr, machine->sshName, buildStepStatus, result.errorMsg);

            for (auto build2 : dependents) {
                printMsg(lvlError, format("marking build %1% as failed") % build2->id);
                txn.parameterized
                    ("update Builds set finished = 1, busy = 0, buildStatus = $2, startTime = $3, stopTime = $4, isCachedBuild = $5 where id = $1")
                    (build2->id)
                    ((int) (build2->drvPath == step->drvPath ? bsFailed : bsDepFailed))
                    (result.startTime)
                    (result.stopTime)
                    (cachedFailure ? 1 : 0).exec();
                build2->finishedInDB = true; // FIXME: txn might fail
            }

            if (!retry)
                for (auto build2 : dependents) {
                    printMsg(lvlError, format("marking build %1% as failed") % build2->id);
                    txn.parameterized
                        ("update Builds set finished = 1, busy = 0, buildStatus = $2, startTime = $3, stopTime = $4, isCachedBuild = $5 where id = $1")
                        (build2->id)
                        ((int) (build2->drvPath != step->drvPath && buildStatus == bsFailed ? bsDepFailed : buildStatus))
                        (result.startTime)
                        (result.stopTime)
                        (cachedFailure ? 1 : 0).exec();
                    build2->finishedInDB = true; // FIXME: txn might fail
                }

    for (auto build2 : dependents)
        if (build2->toplevel == step || result.status != RemoteResult::rrSuccess) {
            auto builds_(builds.lock());
            builds_->erase(build2->id);
        }

    if (!retry)
        for (auto build2 : dependents)
            if (build2->toplevel == step || result.status != RemoteResult::rrSuccess) {
                auto builds_(builds.lock());
                builds_->erase(build2->id);
            }

    destroyStep(step, result.status == RemoteResult::rrSuccess);

    if (!retry)
        destroyStep(step, result.status == RemoteResult::rrSuccess);
    return retry;

    printMsg(lvlError, format("%1% times woken up to check the queue") % nrQueueWakeups);

    printMsg(lvlError, format("%1% build step retries") % nrRetries);
    printMsg(lvlError, format("%1% most retries for any build step") % maxNrRetries);
    printMsg(lvlError, format("%1% queue wakeups") % nrQueueWakeups);
    printMsg(lvlError, format("%1% dispatcher wakeups") % nrDispatcherWakeups);
    printMsg(lvlError, format("%1% database connections") % dbPool.count());

    //printMsg(lvlInfo, "exiting...");
    //printMsg(lvlInfo, format("psql connections = %1%") % dbPool.count());

                <span class="error">Aborted</span>

                <span class="error"><strong>Aborted</strong>[% IF step.errormsg %]: [% HTML.escape(step.errormsg); END %]</span>

-- FIXME: remove