<T> void run(ConsumerAction<? extends T> action, ResultHandlerVersion1<? super T> handler);

    /**
     * Stops this connection, blocking until all operations on the connection have completed.
     */
    void stop();

    String getDisplayName();

    /**
     * Requests cancellation on the current operation and send a 'stop when idle' message to the daemon.
     */
    void disconnect();

	LoopbackClientConfig *restclient.Config
	// StopCh is the channel that will be closed when the server stops.
	//
	// Deprecated: use the PostStartHookContext itself instead, it contains a context that
	// gets cancelled when the server stops. StopCh keeps getting provided for existing code.
	StopCh <-chan struct{}
	// Context gets cancelled when the server stops.
	context.Context
}

     * The returned {@link Timeout} object must be used to stop the timeout once the thread has completed
     * the work that this timeout was supposed to limit, otherwise it may be interrupted doing
     * some other work later.
     */
    Timeout start(Thread taskExecutionThread, Duration timeoutInMillis, Describable workUnitDescription, @Nullable BuildOperationRef buildOperationRef);

    /**
     * Stops all {@link Timeout}s created from this handler.

    def setup() {
        waitFor = new PollingConditions(timeout: 60, initialDelay: 0, factor: 1.25)
        toolingApi.requireIsolatedDaemons()
    }

    @TargetGradleVersion(">=6.5")
    def "disconnect during build stops daemon"() {
        setup:
        buildFile.text = """
            task hang {
                doLast {
                    ${server.callFromBuild("waiting")}
                }
            }

    /**
     * Disconnects from the process without waiting for further work.
     */
    void disconnect();

    /**
     * Stops doing work with the process's streams. Should block until no further asynchronous work is happening on the streams.
     */
    @Override
    void stop();

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * A handler that stops all worker daemons when the build is cancelled.
 */
@ServiceScope(Scope.BuildSession.class)
@NonNullApi
public class WorkerDaemonClientCancellationHandler implements Stoppable {

     */
    Address start(IncomingConnectionHandler handler, Runnable connectionErrorHandler);

    /**
     * Stops accepting new connections, and blocks until all active connections close.
     */
    @Override
    public void stop();

            There's a potential problem here in that DisconnectableInputStream reads from input in the background.
            This won't automatically stop when the process is over. Therefore, if input is not closed then this thread
            will run forever. It would be better to ensure that this thread stops when the process does.
         */
        InputStream instr = new DisconnectableInputStream(input);

	// for running a pod, the scheduler stops its search for more feasible nodes in
	// the cluster. This helps improve scheduler's performance. Scheduler always tries to find
	// at least "minFeasibleNodesToFind" feasible nodes no matter what the value of this flag is.
	// Example: if the cluster size is 500 nodes and the value of this flag is 30,
	// then scheduler stops finding further feasible nodes once it finds 150 feasible ones.

            true
        }

        when:
        controller.load(key, cacheableEntity)

        then:
        0 * local.storeLocally(key, _)
    }

    def "stops calling through after read error"() {
        local = null

        when:
        def controller = getController()
        controller.load(key, cacheableEntity)
        controller.load(key, cacheableEntity)