return new TimeTrackingProcessor(processor, processorResult);
    }

    private void cleanupProcessors() {
        CompositeStoppable.stoppable(processorClassloader).stop();
    }

        } catch (e: Exception) {
            throw RuntimeException("Could not load entry for $key", e)
        }
    }

    override fun close() {
        CompositeStoppable.stoppable(valuesStore).stop()
    }

    }

    @Override
    public void close() {
        lock.lock();
        try {
            CompositeStoppable.stoppable(dirCaches.values()).stop();
        } finally {
            dirCaches.clear();
            lock.unlock();
        }
    }

    private PersistentCache doOpen(
        File cacheDir,

    public void requestStop() {
        hub.requestStop();
    }

    @Override
    public void stop() {
        // TODO:ADAM - need to cleanup completion too, if not used
        CompositeStoppable.stoppable(hub, connection).stop();
    }

    @Override
    public void abort() {
        aborted = true;
        stop();
    }

    @Override

                projectsById.remove(project.identifier);
                projectsByPath.remove(project.identityPath);
            }
            CompositeStoppable.stoppable(registry.projectsByPath.values()).stop();
            registry.projectsByPath.clear();
        }
    }

            DaemonStopState stopState = daemon.stopOnExpiration(expirationStrategy, parameters.getPeriodicCheckIntervalMs());
            daemonProcessState.stopped(stopState);
        } finally {
            CompositeStoppable.stoppable(daemon, daemonProcessState).stop();
        }
    }

    private static void invalidArgs(String message) {
        System.out.println("USAGE: <gradle version>");
        System.out.println(message);

            } finally {
                lock.unlock()
            }
        }

        @Override
        void stop() {
            lock.lock()
            try {
                CompositeStoppable.stoppable(acceptor, connection).stop()
            } finally {
                connection = null
                acceptor = null
                lock.unlock()
            }
            services.close()
        }

        child.addProvider(new ServiceRegistrationProvider() {
            @Provides
            Stoppable createCloseableService(Closeable dependency) {
                childService
            }
        })

        when:
        def service = child.get(Stoppable)
        registry.close()

        then:
        service == childService
        1 * parentService.close()

import groovy.json.JsonOutput;
import groovy.json.JsonSlurper;
import org.gradle.StartParameter;
import org.gradle.api.NonNullApi;
import org.gradle.internal.UncheckedException;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.BuildOperationListener;
import org.gradle.internal.operations.BuildOperationListenerManager;

            subscribed.stream()
                .flatMap(it -> it.getListeners().stream())
                .forEach(this::unsubscribe);
            CompositeStoppable.stoppable(subscribed).stop();
        } finally {
            subscriptions.clear();
        }
    }

    private void unsubscribe(Object listener) {
        listenerManager.removeListener(listener);