1 files changed, 23 insertions, 86 deletions

diff --git a/src/libstore/build/goal.hh b/src/libstore/build/goal.hh
index 189505308..29540dcd3 100644
--- a/src/libstore/build/goal.hh
+++ b/src/libstore/build/goal.hh
@@ -1,10 +1,12 @@
 #pragma once
 ///@file
 
+#include "async-semaphore.hh"
 #include "result.hh"
 #include "types.hh"
 #include "store-api.hh"
 #include "build-result.hh"
+#include <concepts> // IWYU pragma: keep
 #include <kj/async.h>
 
 namespace nix {
@@ -19,22 +21,11 @@ class Worker;
  * A pointer to a goal.
  */
 typedef std::shared_ptr<Goal> GoalPtr;
-typedef std::weak_ptr<Goal> WeakGoalPtr;
-
-struct CompareGoalPtrs {
-    bool operator() (const GoalPtr & a, const GoalPtr & b) const;
-};
 
 /**
  * Set of goals.
  */
-typedef std::set<GoalPtr, CompareGoalPtrs> Goals;
-typedef std::set<WeakGoalPtr, std::owner_less<WeakGoalPtr>> WeakGoals;
-
-/**
- * A map of paths to goals (and the other way around).
- */
-typedef std::map<StorePath, WeakGoalPtr> WeakGoalMap;
+typedef std::set<GoalPtr> Goals;
 
 /**
  * Used as a hint to the worker on how to schedule a particular goal. For example,
@@ -70,17 +61,6 @@ struct Goal
     const bool isDependency;
 
     /**
-     * Goals that this goal is waiting for.
-     */
-    Goals waitees;
-
-    /**
-     * Goals waiting for this one to finish.  Must use weak pointers
-     * here to prevent cycles.
-     */
-    WeakGoals waiters;
-
-    /**
      * Number of goals we are/were waiting for that have failed.
      */
     size_t nrFailed = 0;
@@ -102,57 +82,37 @@ struct Goal
      */
     std::string name;
 
-    /**
-     * Whether the goal is finished.
-     */
-    std::optional<ExitCode> exitCode;
-
-    /**
-     * Build result.
-     */
-    BuildResult buildResult;
+protected:
+    AsyncSemaphore::Token slotToken;
 
 public:
-
-    struct [[nodiscard]] StillAlive {};
-    struct [[nodiscard]] WaitForSlot {};
-    struct [[nodiscard]] WaitForAWhile {};
-    struct [[nodiscard]] ContinueImmediately {};
-    struct [[nodiscard]] WaitForGoals {
-        Goals goals;
-    };
-    struct [[nodiscard]] WaitForWorld {
-        std::set<int> fds;
-        bool inBuildSlot;
-    };
-    struct [[nodiscard]] Finished {
+    struct [[nodiscard]] WorkResult {
         ExitCode exitCode;
-        BuildResult result;
-        std::shared_ptr<Error> ex;
+        BuildResult result = {};
+        std::shared_ptr<Error> ex = {};
         bool permanentFailure = false;
         bool timedOut = false;
         bool hashMismatch = false;
         bool checkMismatch = false;
     };
 
-    struct [[nodiscard]] WorkResult : std::variant<
-                                          StillAlive,
-                                          WaitForSlot,
-                                          WaitForAWhile,
-                                          ContinueImmediately,
-                                          WaitForGoals,
-                                          WaitForWorld,
-                                          Finished>
+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
     {
-        WorkResult() = delete;
-        using variant::variant;
-    };
+        return waitForGoals(
+            kj::arrOf<std::pair<GoalPtr, kj::Promise<Result<WorkResult>>>>(std::move(goals)...)
+        );
+    }
 
-    /**
-     * Exception containing an error message, if any.
-     */
-    std::shared_ptr<Error> ex;
+    virtual kj::Promise<Result<WorkResult>> workImpl() noexcept = 0;
 
+public:
     explicit Goal(Worker & worker, bool isDependency)
         : worker(worker)
         , isDependency(isDependency)
@@ -163,24 +123,10 @@ public:
         trace("goal destroyed");
     }
 
-    virtual kj::Promise<Result<WorkResult>> work(bool inBuildSlot) noexcept = 0;
+    kj::Promise<Result<WorkResult>> work() noexcept;
 
     virtual void waiteeDone(GoalPtr waitee) { }
 
-    virtual WorkResult handleChildOutput(int fd, std::string_view data)
-    {
-        abort();
-    }
-
-    virtual void handleEOF(int fd)
-    {
-    }
-
-    virtual bool respectsTimeouts()
-    {
-        return false;
-    }
-
     void trace(std::string_view s);
 
     std::string getName() const
@@ -188,15 +134,6 @@ public:
         return name;
     }
 
-    /**
-     * Callback in case of a timeout.  It should wake up its waiters,
-     * get rid of any running child processes that are being monitored
-     * by the worker (important!), etc.
-     */
-    virtual Finished timedOut(Error && ex) = 0;
-
-    virtual std::string key() = 0;
-
     virtual void cleanup() { }
 
     /**