TokenServer & copyClosureTokenServer,

    /* Ensure that only a limited number of threads can copy closures
       at the same time. However, proceed anyway after a timeout to
       prevent starvation by a handful of really huge closures. */
    time_t start = time(0);
    int timeout = 60 * (10 + rand() % 5);
    auto token(copyClosureTokenServer.get(timeout));
    time_t stop = time(0);
    if (token())
        printMsg(lvlDebug, format("got copy closure token after %1%s") % (stop - start));
    else
        printMsg(lvlDebug, format("dit not get copy closure token after %1%s") % (stop - start));

    TokenServer & copyClosureTokenServer,

    copyClosureTo(store, from, to, inputs);

    copyClosureTo(store, from, to, inputs, copyClosureTokenServer);

#include "token-server.hh"

    TokenServer & copyClosureTokenServer,

#include "token-server.hh"

const int maxTries = 5;
const int retryInterval = 60; // seconds

// FIXME: Make configurable.
const unsigned int maxTries = 5;
const unsigned int retryInterval = 60; // seconds

const unsigned int maxParallelCopyClosure = 4;

    /* Token server limiting the number of threads copying closures in
       parallel to prevent excessive I/O load. */
    TokenServer copyClosureTokenServer{maxParallelCopyClosure};

                logDir, build->maxSilentTime, build->buildTimeout, result, nrStepsBuilding);

                logDir, build->maxSilentTime, build->buildTimeout, copyClosureTokenServer,
                result, nrStepsBuilding);

#include <cassert>

        }
        template<class Rep, class Period, class Predicate>
        bool wait_for(std::condition_variable_any & cv,
            const std::chrono::duration<Rep, Period> & duration,
            Predicate pred)
        {
            assert(s);
            return cv.wait_for(s->mutex, duration, pred);

#pragma once
#include <atomic>
#include "sync.hh"
/* This class hands out tokens. There are only ‘maxTokens’ tokens
   available. Calling get() will return a Token object, representing
   ownership of a token. If no token is available, get() will sleep
   until another thread returns a token. */
class TokenServer
{
    unsigned int maxTokens;
    Sync<unsigned int> curTokens{0};
    std::condition_variable_any wakeup;
public:
    TokenServer(unsigned int maxTokens) : maxTokens(maxTokens) { }
    class Token
    {
        friend TokenServer;
        TokenServer * ts;
        bool acquired = false;
        Token(TokenServer * ts, unsigned int timeout) : ts(ts)
        {
            auto curTokens(ts->curTokens.lock());
            while (*curTokens >= ts->maxTokens)
                if (timeout) {
                    if (!curTokens.wait_for(ts->wakeup, std::chrono::seconds(timeout),
                            [&]() { return *curTokens < ts->maxTokens; }))
                        return;
                } else
                    curTokens.wait(ts->wakeup);
            (*curTokens)++;
            acquired = true;
        }
    public:
        Token(Token && t) : ts(t.ts) { t.ts = 0; }
        Token(const Token & l) = delete;
        ~Token()
        {
            if (!ts || !acquired) return;
            {
                auto curTokens(ts->curTokens.lock());
                assert(*curTokens);
                (*curTokens)--;
            }
            ts->wakeup.notify_one();
        }
        bool operator ()() { return acquired; }
    };
    Token get(unsigned int timeout = 0)
    {
        return Token(this, timeout);
    }
};