remote-store-connection.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libstore/remote-store.hh"
#include "lix/libstore/worker-protocol.hh"
#include "lix/libutil/pool.hh"
 
namespace nix {

struct RemoteStore::Connection
{
    FdSink to;

    FdSource from;

    WorkerProto::Version daemonVersion;

    std::optional<TrustedFlag> remoteTrustsUs;

    std::optional<std::string> daemonNixVersion;

    std::chrono::time_point<std::chrono::steady_clock> startTime;

    operator WorkerProto::ReadConn ()
    {
        return WorkerProto::ReadConn {from, daemonVersion};
    }

    operator WorkerProto::WriteConn ()
    {
        return WorkerProto::WriteConn {daemonVersion};
    }
 
    virtual ~Connection();
 
    virtual void closeWrite() = 0;
 
    std::exception_ptr processStderr(Sink * sink = 0, Source * source = 0, bool flush = true);
};

struct RemoteStore::ConnectionHandle
{
    Pool<RemoteStore::Connection>::Handle handle;
    Sync<ThreadPool> & handlerThreads;
    bool daemonException = false;
 
    ConnectionHandle(
        Pool<RemoteStore::Connection>::Handle && handle, Sync<ThreadPool> & handlerThreads
    )
        : handle(std::move(handle))
        , handlerThreads(handlerThreads)
    {
    }
 
    ConnectionHandle(ConnectionHandle && h)
        : handle(std::move(h.handle))
        , handlerThreads(h.handlerThreads)
        , daemonException(h.daemonException)
    {
        h.daemonException = false;
    }
 
    ~ConnectionHandle();
 
    RemoteStore::Connection & operator * () { return *handle; }
    RemoteStore::Connection * operator -> () { return &*handle; }
 
    void processStderr(Sink * sink = 0, Source * source = 0, bool flush = true);
 
    void withFramedSink(std::function<void(Sink & sink)> fun);
    kj::Promise<Result<void>>
    withFramedSinkAsync(std::function<kj::Promise<Result<void>>(Sink & sink)> fun);
 
private:
    struct FramedSinkHandler
    {
        std::exception_ptr ex;
        std::packaged_task<void()> stderrHandler;
 
        explicit FramedSinkHandler(ConnectionHandle & conn, ThreadPool & handlerThreads);
 
        ~FramedSinkHandler() noexcept(false);
    };
};
 
}