}
    }

    @Override
    public void disconnect() {
        lock.lock();
        try {
            if (stopped || connection == null) {
                return;
            }
            requestCancellation();
            sendStopWhenIdleMessageToDaemons();
        } finally {
            stopped = true;
            lock.unlock();
        }
    }

    private void requestCancellation() {

     * Creates an executor which can run multiple actions concurrently. It is the caller's responsibility to stop the executor.
     *
     * The executor will collect failures thrown by actions and rethrow when the executor is stopped.
     *
     * @param displayName The display name for the this executor. Used for thread names, logging and error message.
     * @return The executor.
     */
    ManagedExecutor create(String displayName);

    /**

        then:
        def e = thrown(IllegalStateException)
        e.message == "Cannot modify deployment handles once the registry has been stopped."
    }

    def "cannot register a handle once the registry is stopped" () {
        given:
        registry.stop()

        when:
        registry.start("id", DeploymentRegistry.ChangeBehavior.NONE, TestDeploymentHandle)
        then:

 * limitations under the License.
 */

package org.gradle.launcher.daemon.server.api;

/**
 * Thrown when the daemon is stopped while running a command.
 */
public class DaemonStoppedException extends RuntimeException {
    public static final String MESSAGE = "Gradle build daemon has been stopped";

    public DaemonStoppedException() {
        super(MESSAGE);
    }

    public DaemonStoppedException(String reason) {

	// eventBroadcaster
	// 2. Shutdown the m.incoming slightly Before m.stopped so that the watcher's
	// call of Blockqueue can pass the m.stopped check.
	m.blockQueue(func() {
		close(stopCh)
		close(m.incoming)
		time.Sleep(1 * time.Millisecond)
		close(m.stopped)
	})
	m.distributing.Wait()

        this
    }

    DaemonFixture stops() {
        waitForState(Stopped)
        this
    }

    @Override
    void assertIdle() {
        assertHasState(Idle)
    }

    @Override
    void assertBusy() {
        assertHasState(Busy)
    }

    @Override
    void assertStopped() {
        assertHasState(Stopped)
    }

    @Override
    void assertCanceled() {

    private final DistributionFactory distributionFactory;
    private Distribution distribution;

    private final List<DefaultProjectConnection> connections = new ArrayList<DefaultProjectConnection>(4);
    private boolean stopped = false;

    private final DefaultConnectionParameters.Builder connectionParamsBuilder = DefaultConnectionParameters.builder();

	workloadSds *sdsservice

	grpcWorkloadListener net.Listener

	grpcWorkloadServer *grpc.Server
	stopped            *atomic.Bool
}

// NewServer creates and starts the Grpc server for SDS.
func NewServer(options *security.Options, workloadSecretCache security.SecretManager, pkpConf *mesh.PrivateKeyProvider) *Server {
	s := &Server{stopped: atomic.NewBool(false)}
	s.workloadSds = newSDSService(workloadSecretCache, options, pkpConf)

     */
    <T> T onExecute(Callable<T> command) throws Exception;

    /**
     * Special behavior after an executor is stopped.
     *
     * This is called after the underlying Executor has been stopped.
     */
    void onStop();

    /**
     * Runs the Runnable, catches all Throwables and logs them.
     *

    }

    def "reports exact number of daemons stopped and keeps console output clean"() {
        given:
        executer.noExtraLogging()
        executer.run()

        when:
        def out = executer.withArguments("--stop").run().normalizedOutput

        then:
        out == '''Stopping Daemon(s)
1 Daemon stopped
'''

        when: