#pragma once
#include <memory>
#include <list>
#include "sync.hh"
/* This template class implements a simple pool manager of resources
   of some type R, such as database connections. It is used as
   follows:
     class Connection { ... };
     Pool<Connection> pool;
     {
       auto conn(pool.get());
       conn->exec("select ...");
     }
   Here, the Connection object referenced by ‘conn’ is automatically
   returned to the pool when ‘conn’ goes out of scope.
*/
template <class R>
class Pool
{
private:
    struct State
    {
        unsigned int count = 0;
        std::list<std::shared_ptr<R>> idle;
    };
    Sync<State> state;
public:
    class Handle
    {
    private:
        Pool & pool;
        std::shared_ptr<R> r;
        friend Pool;
        Handle(Pool & pool, std::shared_ptr<R> r) : pool(pool), r(r) { }
    public:
        Handle(Handle && h) : pool(h.pool), r(h.r) { h.r.reset(); }
        Handle(const Handle & l) = delete;
        ~Handle()
        {
            auto state_(pool.state.lock());
            if (r) state_->idle.push_back(r);
        }
        R * operator -> () { return r.get(); }
        R & operator * () { return *r; }
    };
    Handle get()
    {
        {
            auto state_(state.lock());
            if (!state_->idle.empty()) {
                auto p = state_->idle.back();
                state_->idle.pop_back();
                return Handle(*this, p);
            }
            state_->count++;
        }
        /* Note: we don't hold the lock while creating a new instance,
           because creation might take a long time. */
    }
    unsigned int count()
    {
        auto state_(state.lock());
        return state_->count;
    }
};
        return Handle(*this, factory());
    Pool(const Factory & factory = []() { return std::make_shared<R>(); })
        : factory(factory)
    { }
    Factory factory;
public:
    typedef std::function<std::shared_ptr<R>()> Factory;
#include <functional>

#pragma once
#include <mutex>
#include <condition_variable>
/* This template class ensures synchronized access to a value of type
   T. It is used as follows:
     struct Data { int x; ... };
     Sync<Data> data;
     {
       auto data_(data.lock());
       data_->x = 123;
     }
   Here, "data" is automatically unlocked when "data_" goes out of
   scope.
*/
class Sync
{
private:
    std::mutex mutex;
    T data;
public:
    class Lock
    {
    private:
        Sync * s;
        friend Sync;
        Lock(Sync * s) : s(s) { s->mutex.lock(); }
    public:
        Lock(Lock && l) : s(l.s) { l.s = 0; }
        Lock(const Lock & l) = delete;
        ~Lock() { if (s) s->mutex.unlock(); }
        T * operator -> () { return &s->data; }
        T & operator * () { return s->data; }
        /* FIXME: performance impact of condition_variable_any? */
        void wait(std::condition_variable_any & cv)
        {
            assert(s);
            cv.wait(s->mutex);
        }
    };
    Lock lock() { return Lock(this); }
};
        }
        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);
        }
        template<class Clock, class Duration>
        std::cv_status wait_until(std::condition_variable_any & cv,
            const std::chrono::time_point<Clock, Duration> & duration)
        {
            assert(s);
            return cv.wait_until(s->mutex, duration);
    Sync() { }
    Sync(const T & data) : data(data) { }
template<class T>
#include <cassert>

BinaryCacheStore::BinaryCacheStore(const StoreFactory & storeFactory,

BinaryCacheStore::BinaryCacheStore(std::shared_ptr<Store> localStore,

    : storeFactory(storeFactory)

    : localStore(localStore)

    auto localStore = storeFactory();

    if (!localStore) return;

        if (!(*localStore)->isValidPath(storePath)) {

        if (!localStore->isValidPath(storePath)) {

        ValidPathInfo info = (*localStore)->queryPathInfo(storePath);

        ValidPathInfo info = localStore->queryPathInfo(storePath);

        (*localStore)->querySubstitutablePathInfos(left, infos);

        localStore->querySubstitutablePathInfos(left, infos);

    auto localStore = storeFactory();

        (*localStore)->addTempRoot(storePath);

        if (!localStore)
            throw Error(format("don't know how to realise path ‘%1%’ in a binary cache") % storePath);

        if (!(*localStore)->isValidPath(storePath))
            (*localStore)->ensurePath(storePath);

        localStore->addTempRoot(storePath);

        ValidPathInfo info = (*localStore)->queryPathInfo(storePath);

        if (!localStore->isValidPath(storePath))
            localStore->ensurePath(storePath);

        ValidPathInfo info = localStore->queryPathInfo(storePath);

/* While BinaryCacheStore is thread-safe, LocalStore and RemoteStore
   aren't. Until they are, use a factory to produce a thread-local
   local store. */
typedef Pool<nix::ref<nix::Store>> StorePool;
typedef std::function<StorePool::Handle()> StoreFactory;

    StoreFactory storeFactory;

    std::shared_ptr<Store> localStore;

    BinaryCacheStore(const StoreFactory & storeFactory,

    BinaryCacheStore(std::shared_ptr<Store> localStore,

    : localStorePool([]() { return std::make_shared<ref<Store>>(openStore()); })

StorePool::Handle State::getLocalStore()

ref<Store> State::getLocalStore()

    auto conn(localStorePool.get());
    return conn;

    return ref<Store>(_localStore);

    _localStore = openStore();

        _destStore = openStore();

        _destStore = _localStore;

            [this]() { return this->getLocalStore(); },
            "/home/eelco/Misc/Keys/test.nixos.org/secret",
            "/home/eelco/Misc/Keys/test.nixos.org/public",

            _localStore,
            hydraConfig["binary_cache_secret_key_file"],
            hydraConfig["binary_cache_public_key_file"],

            [this]() { return this->getLocalStore(); },

            _localStore,

LocalBinaryCacheStore::LocalBinaryCacheStore(const StoreFactory & storeFactory,

LocalBinaryCacheStore::LocalBinaryCacheStore(std::shared_ptr<Store> localStore,

    : BinaryCacheStore(storeFactory, secretKeyFile, publicKeyFile)

    : BinaryCacheStore(localStore, secretKeyFile, publicKeyFile)

    LocalBinaryCacheStore(const StoreFactory & storeFactory,

    LocalBinaryCacheStore(std::shared_ptr<Store> localStore,

        bool done = getQueuedBuilds(*conn, *localStore, destStore, lastBuildId);

        bool done = getQueuedBuilds(*conn, localStore, destStore, lastBuildId);

S3BinaryCacheStore::S3BinaryCacheStore(const StoreFactory & storeFactory,

S3BinaryCacheStore::S3BinaryCacheStore(std::shared_ptr<Store> localStore,

    : BinaryCacheStore(storeFactory, secretKeyFile, publicKeyFile)

    : BinaryCacheStore(localStore, secretKeyFile, publicKeyFile)

    S3BinaryCacheStore(const StoreFactory & storeFactory,

    S3BinaryCacheStore(std::shared_ptr<Store> localStore,

    Sync<std::map<time_t, time_t>> steps;

    nix::Sync<std::map<time_t, time_t>> steps;

    Sync<State> state;

    nix::Sync<State> state;

        Sync<ConnectInfo> connectInfo;

        nix::Sync<ConnectInfo> connectInfo;

    Sync<Builds> builds;

    nix::Sync<Builds> builds;

    Sync<Jobsets> jobsets;

    nix::Sync<Jobsets> jobsets;

    Sync<Steps> steps;

    nix::Sync<Steps> steps;

    Sync<Runnable> runnable;

    nix::Sync<Runnable> runnable;

    Sync<bool> dispatcherWakeup;
    std::condition_variable_any dispatcherWakeupCV;

    nix::Sync<bool> dispatcherWakeup;
    std::condition_variable dispatcherWakeupCV;

    Pool<Connection> dbPool;

    nix::Pool<Connection> dbPool;

    Sync<Machines> machines; // FIXME: use atomic_shared_ptr

    nix::Sync<Machines> machines; // FIXME: use atomic_shared_ptr

    Sync<std::queue<nix::Path>> logCompressorQueue;
    std::condition_variable_any logCompressorWakeup;

    nix::Sync<std::queue<nix::Path>> logCompressorQueue;
    std::condition_variable logCompressorWakeup;

    Sync<std::queue<NotificationItem>> notificationSenderQueue;
    std::condition_variable_any notificationSenderWakeup;

    nix::Sync<std::queue<NotificationItem>> notificationSenderQueue;
    std::condition_variable notificationSenderWakeup;

    Sync<std::map<std::string, MachineType>> machineTypes;

    nix::Sync<std::map<std::string, MachineType>> machineTypes;

    /* Pool of local stores. */
    nix::StorePool localStorePool;
    /* Destination store. */

    std::shared_ptr<nix::Store> _localStore;

    nix::StorePool::Handle getLocalStore();

    nix::ref<nix::Store> getLocalStore();

    std::condition_variable_any wakeup;

    std::condition_variable wakeup;