@EventScope(Scope.Build.class)
public interface TaskListenerInternal {
    /**
     * This method is called immediately before a task is executed.
     *
     * @param taskIdentity The identity of the task about to be executed. Never null.
     */
    void beforeExecute(TaskIdentity<?> taskIdentity);

    /**
     * This method is call immediately after a task has been executed. It is always called, regardless of whether the

@EventScope(Scope.BuildTree.class)
@StatefulListener
public interface RootBuildLifecycleListener {
    /**
     * Called at the start of the root build, immediately after the creation of the root build services.
     */
    void afterStart();

    /**
     * Called at the completion of the root build, immediately before destruction of the root build services.
     */
    void beforeComplete();

@Deprecated
@DeprecatedInGradleScope
public interface TaskExecutionListener {
    /**
     * This method is called immediately before a task is executed.
     *
     * @param task The task about to be executed. Never null.
     */
    void beforeExecute(Task task);

    /**
     * This method is called immediately after a task has been executed. It is always called, regardless of whether the

   *     arbitrary past or present time
   */
  abstract long queryEarliestAvailable(long nowMicros);

  /**
   * Reserves the requested number of permits and returns the time that those permits can be used
   * (with one caveat).
   *
   * @return the time that the permits may be used, or, if the permits may be used immediately, an
   *     arbitrary past or present time

    }

    def "requestForcefulStop stops immediately when idle"() {
        expect:
        notStopped

        when:
        coordinator.requestForcefulStop("stop")

        then:
        coordinator.willRefuseNewCommands
        stopped
        0 * _._
    }

    def "requestForcefulStop causes command to be abandoned immediately"() {
        def command = Mock(Runnable)

    code: Int,
    reason: String?,
  ): Boolean

  /**
   * Immediately and violently release resources held by this web socket, discarding any enqueued
   * messages. This does nothing if the web socket has already been closed or canceled.
   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new web socket and immediately returns it. Creating a web socket initiates an

     * <p>May be called by any thread. This method returns immediately and does not block to wait for any currently running or pending calls to {@link #update(Function)} to complete.
     */
    T get() throws IllegalStateException;

    /**
     * Returns the current value, returning {@code null} if not present.
     *

    /**
     * Called at the start of the session, immediately after initializing the session services.
     *
     * This method is called before the root build operation has started, so implementations should not perform any expensive work
     * and should not run any user code.
     */
    default void afterStart() {
    }

    /**
     * Called at the completion of the session, immediately prior to tearing down the session services.
     *

        startBuild()

        then:
        busy()

        when:
        startBuild()

        then:
        busy 2
    }

    def "sending stop to idle daemons causes them to terminate immediately"() {
        when:
        startBuild()

        then:
        busy()

        when:
        completeBuild()

        then:
        idle()

        when:
        stopDaemons()

// Instance is a server that is composed a number of Component tasks.
type Instance interface {
	// Start this Server. Any components that were already added
	// will be run immediately. If any error is returned,
	// Start will terminate and return the error immediately.
	//
	// Once all startup components have been run, starts a polling
	// loop to continue monitoring for new components and returns nil.
	Start(stop <-chan struct{}) error