* limitations under the License.
 */
package org.gradle.internal.concurrent;

/**
 * Represents an object which performs concurrent activity.
 */
public interface Stoppable {
    /**
     * <p>Requests a graceful stop of this object. Blocks until all concurrent activity has been completed.</p>
     *
     * <p>If this object has already been stopped, this method does nothing.</p>
     */

        this.elements.add(toStoppable(closeable));
        return this;
    }

    private static Stoppable toStoppable(final Object object) {
        if (object instanceof Stoppable) {
            return (Stoppable) object;
        }
        if (object instanceof Closeable) {
            final Closeable closeable = (Closeable) object;
            return new Stoppable() {
                @Override

class CompositeStoppableTest extends Specification {
    private final CompositeStoppable stoppable = new CompositeStoppable()

    def stopsAllElementsOnStop() {
        Stoppable a = Mock()
        Stoppable b = Mock()
        stoppable.add(a)
        stoppable.add(b)

        when:
        stoppable.stop()

        then:
        1 * a.stop()
        1 * b.stop()
    }

 */
package org.gradle.internal.concurrent;

/**
 * A {@link Stoppable} object whose stop process can be performed asynchronously.
 */
public interface AsyncStoppable extends Stoppable {
    /**
     * <p>Requests that this stoppable commence a graceful stop. Does not block. You should call {@link
     * Stoppable#stop} to wait for the stop process to complete.</p>
     *

    private final ServiceRegistry sharedServices;
    private final Stoppable stoppable;

    public RunBuildAction(
        BuildActionExecutor<BuildActionParameters, ClientBuildRequestContext> executor, StartParameterInternal startParameter, GradleLauncherMetaData clientMetaData, long startTime,
        BuildActionParameters buildActionParameters, ServiceRegistry sharedServices, Stoppable stoppable) {
        this.executor = executor;

        return Optional.ofNullable(execHandle.getExecResult());
    }

    private void cleanup() {
        CompositeStoppable stoppable;
        lock.lock();
        try {
            stoppable = CompositeStoppable.stoppable(connection, new Stoppable() {
                @Override
                public void stop() {
                    execHandle.abort();
                }
            }, acceptor);

    final long startTime = 90
    final BuildActionParameters parameters = Mock()
    final ServiceRegistry sharedServices = Mock()
    final Stoppable stoppable = Mock()
    final RunBuildAction action = new RunBuildAction(client, startParameter, clientMetaData, startTime, parameters, sharedServices, stoppable)

    def runsBuildUsingDaemon() {
        when:
        action.run()

        then:

        clientConnection.addUnrecoverableErrorHandler(new Action<Throwable>() {
            @Override
            public void execute(Throwable throwable) {
                if (action instanceof Stoppable) {
                    ((Stoppable) action).stop();
                }
            }
        });

        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();

        project.getExtensions().getExtraProperties().set(
            "ProjectBuilder.stoppable",
            stoppable(
                (Stoppable) workerLeaseService::runAsIsolatedTask,
                (Stoppable) workerLease::leaseFinish,
                buildServices,
                buildTreeState,
                buildSessionState,

                }
                stoppable.add(services.registry);
            }
            servicesForHomeDir.clear();
        } finally {
            lock.unlock();
        }
        stoppable.stop();
    }

    @Override
    public ServiceRegistry getServicesFor(final File gradleUserHomeDir) {
        lock.lock();