BuildResult getBuildResult(const Derivation & drv)

BuildResult getBuildResult(std::shared_ptr<StoreAPI> store, const Derivation & drv)

#include <memory>

BuildResult getBuildResult(const nix::Derivation & drv);

BuildResult getBuildResult(std::shared_ptr<nix::StoreAPI> store, const nix::Derivation & drv);

#include <atomic>
#include <condition_variable>

#include <memory>

#include <memory>
#include <thread>

std::mutex exitRequestMutex;
std::condition_variable exitRequest;
bool exitRequested(false);

static std::atomic_int _int(0);

void sigintHandler(int signo)
{
    _int = 1;
}
void signalThread()
{
    struct sigaction act;
    act.sa_handler = sigintHandler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGINT, &act, 0))
        throw SysError("installing handler for SIGINT");
    while (true) {
        sleep(1000000);
        if (_int) break;
    }
    {
        std::lock_guard<std::mutex> lock(exitRequestMutex);
        exitRequested = true;
    }
    exitRequest.notify_all();
}

    std::thread queueMonitorThread;

    std::mutex runnableMutex;
    std::condition_variable runnableCV;

    void getQueuedBuilds(pqxx::connection & conn);

    void queueMonitorThreadEntry();
    void getQueuedBuilds(std::shared_ptr<StoreAPI> store, pqxx::connection & conn);

    Step::ptr createStep(const Path & drvPath);

    Step::ptr createStep(std::shared_ptr<StoreAPI> store, const Path & drvPath);

    void doBuildSteps();

    void makeRunnable(Step::ptr step);

    void doBuildStep(Step::ptr step);

    void builderThreadEntry(int slot);
    void doBuildStep(std::shared_ptr<StoreAPI> store, Step::ptr step);

    void run();

void State::getQueuedBuilds(pqxx::connection & conn)

void State::queueMonitorThreadEntry()
{
    auto store = openStore(); // FIXME: pool
    Connection conn;
    while (true) {
        getQueuedBuilds(store, conn);
        {
            std::unique_lock<std::mutex> lock(exitRequestMutex);
            exitRequest.wait_for(lock, std::chrono::seconds(5));
            if (exitRequested) break;
        }
    }
    printMsg(lvlError, "queue monitor exits");
}
void State::getQueuedBuilds(std::shared_ptr<StoreAPI> store, pqxx::connection & conn)

    printMsg(lvlError, "checking the queue...");

        Step::ptr step = createStep(build->drvPath);

        Step::ptr step = createStep(store, build->drvPath);

            BuildResult res = getBuildResult(drv);

            BuildResult res = getBuildResult(store, drv);

Step::ptr State::createStep(const Path & drvPath)

Step::ptr State::createStep(std::shared_ptr<StoreAPI> store, const Path & drvPath)

        Step::ptr dep = createStep(i.first);

        Step::ptr dep = createStep(store, i.first);

    if (step->deps.empty()) runnable.insert(step);

    if (step->deps.empty()) makeRunnable(step);

                runnable.insert(rdep);

                makeRunnable(rdep);

void State::doBuildSteps()

void State::makeRunnable(Step::ptr step)

    while (!runnable.empty()) {
        printMsg(lvlInfo, format("%1% runnable steps") % runnable.size());
        Step::ptr step = *runnable.begin();
        runnable.erase(step);
        doBuildStep(step);

    assert(step->deps.empty());
    {
        std::lock_guard<std::mutex> lock(runnableMutex);
        runnable.insert(step);

    runnableCV.notify_one();

void State::doBuildStep(Step::ptr step)

void State::builderThreadEntry(int slot)
{
    auto store = openStore(); // FIXME: pool
    while (true)  {
        Step::ptr step;
        {
            std::unique_lock<std::mutex> lock(runnableMutex);
            while (runnable.empty())
                runnableCV.wait(lock);
            step = *runnable.begin();
            runnable.erase(step);
        }
        printMsg(lvlError, format("slot %1%: got build step ‘%2%’") % slot % step->drvPath);
        doBuildStep(store, step);
    }
    printMsg(lvlError, "builder thread exits");
}
void State::doBuildStep(std::shared_ptr<StoreAPI> store, Step::ptr step)

    if (success) res = getBuildResult(step->drv);

    if (success) res = getBuildResult(store, step->drv);

}
void State::run()
{
    {
        Connection conn;
        markActiveBuildStepsAsAborted(conn, 0);
    }
    queueMonitorThread = std::thread(&State::queueMonitorThreadEntry, this);
    sleep(1);
    for (int n = 0; n < 4; n++)
        std::thread(&State::builderThreadEntry, this, n).detach();
    queueMonitorThread.join();

        std::thread(signalThread).detach();

        /* Ignore signals. This is inherited by the other threads. */
        sigset_t set;
        sigemptyset(&set);
        sigaddset(&set, SIGHUP);
        sigaddset(&set, SIGINT);
        sigaddset(&set, SIGTERM);
        sigprocmask(SIG_BLOCK, &set, NULL);

        store = openStore();

        Connection conn;

        state.markActiveBuildStepsAsAborted(conn, 0);
        state.getQueuedBuilds(conn);
        state.doBuildSteps();

        state.run();