goal.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/async-semaphore.hh"
#include "lix/libutil/result.hh"
#include "lix/libutil/types.hh"
#include "lix/libstore/store-api.hh"
#include "lix/libstore/build-result.hh"
#include <concepts> // IWYU pragma: keep
#include <kj/async.h>
 
namespace nix {

struct Goal;
class Worker;

typedef std::shared_ptr<Goal> GoalPtr;

typedef std::set<GoalPtr> Goals;

enum struct JobCategory {
    Build,
    Substitution,
};
 
struct Goal
{
    typedef enum {ecSuccess, ecFailed, ecNoSubstituters, ecIncompleteClosure} ExitCode;

    Worker & worker;

    const bool isDependency;

    size_t nrFailed = 0;

    size_t nrNoSubstituters = 0;

    size_t nrIncompleteClosure = 0;

    std::string name;
 
protected:
    AsyncSemaphore::Token slotToken;
 
public:
    struct [[nodiscard]] WorkResult {
        ExitCode exitCode;
        BuildResult result = {};
        std::shared_ptr<Error> ex = {};
        bool permanentFailure = false;
        bool timedOut = false;
        bool hashMismatch = false;
        bool checkMismatch = false;
        std::optional<StorePath> storePath = {};
    };
 
protected:
    kj::Promise<void> waitForAWhile();
    kj::Promise<Result<void>>
    waitForGoals(kj::Array<std::pair<GoalPtr, kj::Promise<Result<WorkResult>>>> dependencies) noexcept;
 
    template<std::derived_from<Goal>... G>
    kj::Promise<Result<void>>
    waitForGoals(std::pair<std::shared_ptr<G>, kj::Promise<Result<WorkResult>>>... goals) noexcept
    {
        return waitForGoals(
            kj::arrOf<std::pair<GoalPtr, kj::Promise<Result<WorkResult>>>>(std::move(goals)...)
        );
    }
 
    virtual kj::Promise<Result<WorkResult>> workImpl() noexcept = 0;
 
    std::string lixAsyncTaskContext() const
    {
        return name;
    }
 
public:
    explicit Goal(Worker & worker, bool isDependency)
        : worker(worker)
        , isDependency(isDependency)
    { }
 
    virtual ~Goal() noexcept(false)
    {
        trace("goal destroyed");
    }
 
    kj::Promise<Result<WorkResult>> work() noexcept;
 
    virtual void waiteeDone(GoalPtr waitee) { }
 
    void trace(std::string_view s);
 
    std::string getName() const
    {
        return name;
    }
 
    virtual void cleanup() { }

    virtual JobCategory jobCategory() const = 0;
};
 
}