{
            /* Disable this machine until a certain period of time has
               passed. This period increases on every consecutive
               failure. However, don't count failures that occurred
               soon after the last one (to take into account steps
               started in parallel). */
            auto info(machine->state->connectInfo.lock());
            auto now = std::chrono::system_clock::now();
            if (info->consecutiveFailures == 0 || info->lastFailure < now - std::chrono::seconds(30)) {
                info->consecutiveFailures = std::min(info->consecutiveFailures + 1, (unsigned int) 4);
                info->lastFailure = now;
                int delta = retryInterval * powf(retryBackoff, info->consecutiveFailures - 1) + (rand() % 30);
                printMsg(lvlInfo, format("will disable machine ‘%1%’ for %2%s") % machine->sshName % delta);
                info->disabledUntil = now + std::chrono::seconds(delta);
            }
        }

    {
        auto info(machine->state->connectInfo.lock());
        info->consecutiveFailures = 0;
    }

            int delta = retryInterval * powf(retryBackoff, step_->tries - 1);

            int delta = retryInterval * powf(retryBackoff, step_->tries - 1) + (rand() % 10);

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

               an ordering. std::sort() can segfault if it isn't. */

               an ordering. std::sort() can segfault if it isn't. Also
               filter out temporarily disabled machines. */

                for (auto & m : *machines_)

                for (auto & m : *machines_) {
                    auto info(m.second->state->connectInfo.lock());
                    if (info->consecutiveFailures && info->disabledUntil > now) {
                        if (info->disabledUntil < sleepUntil)
                            sleepUntil = info->disabledUntil;
                        continue;
                    }

                }

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

        struct ConnectInfo
        {
            system_time lastFailure, disabledUntil;
            unsigned int consecutiveFailures;
        };
        Sync<ConnectInfo> connectInfo;