// hostName when running the container.
	// cleanupAction - action to run when the container is running or it failed to start.
	//
	// CleanupAction must be called immediately after the container with given
	// subpath starts. On the other hand, Interface.CleanSubPaths must be called
	// when the pod finishes.
	PrepareSafeSubpath(subPath Subpath) (newHostPath string, cleanupAction func(), err error)

        def cacheEntries = [
            temporaryFolder.createFile("1"),
            temporaryFolder.createFile("2"),
            temporaryFolder.createFile("3"),
        ]

        when:
        cleanupAction(finder(cacheEntries), { it != cacheEntries[2] })
            .clean(cleanableStore, progressMonitor)

        then:
        1 * cleanableStore.getReservedCacheFiles() >> [cacheEntries[0]]

    }
    def progressMonitor = Stub(CleanupProgressMonitor)

    def "calls configured cleanup actions for correct dirs"() {
        given:
        def firstCleanupAction = Mock(CleanupAction)
        def secondCleanupAction = Mock(CleanupAction)
        def subDir = temporaryFolder.file("subDir")

        when:
        CompositeCleanupAction.builder()
            .add(firstCleanupAction)

package org.gradle.internal.execution.workspace.impl;

import org.gradle.api.internal.cache.CacheConfigurationsInternal;
import org.gradle.cache.CacheBuilder;
import org.gradle.cache.CacheCleanupStrategy;
import org.gradle.cache.CleanupAction;
import org.gradle.cache.DefaultCacheCleanupStrategy;
import org.gradle.cache.FileLockManager;
import org.gradle.cache.PersistentCache;
import org.gradle.cache.internal.LeastRecentlyUsedCacheCleanup;

import org.apache.commons.io.FileUtils;
import org.gradle.cache.CleanableStore;
import org.gradle.cache.CleanupAction;
import org.gradle.cache.CleanupProgressMonitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;

public abstract class AbstractCacheCleanup implements CleanupAction {

    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractCacheCleanup.class);

        private final String displayName;
        private boolean closed;
        private final CleanupAction cleanup;

        public InMemoryCache(File cacheDir, String displayName, @Nullable CleanupAction cleanup) {
            this.cacheDir = cacheDir;
            this.displayName = displayName;
            this.cleanup = cleanup;
        }

        @Override
        public void close() {

    def "reads Gradle version from actual distribution"() {
        given:
        def cleanupAction = new WrapperDistributionCleanupAction(executer.gradleUserHomeDir, Stub(UsedGradleVersions))

        when:
        def gradleVersion = cleanupAction.determineGradleVersionFromDistribution(executer.distribution.gradleHomeDir)

        then:
        gradleVersion == GradleVersion.current()
    }

 * limitations under the License.
 */

package org.gradle.cache;

import java.io.File;
import java.util.Collection;

/**
 * Represents file-based store that can be cleaned by a {@link CleanupAction}.
 */
public interface CleanableStore {

    /**
     * Returns the base directory that should be cleaned for this store.
     */
    File getBaseDir();

    /**

func NewNSEnter(mounter mount.Interface, ne *nsenter.Nsenter, rootDir string) Interface {
	return nil
}

func (sp *subpath) PrepareSafeSubpath(subPath Subpath) (newHostPath string, cleanupAction func(), err error) {
	return subPath.Path, nil, errUnsupported
}

func (sp *subpath) CleanSubPaths(podDir string, volumeName string) error {
	return errUnsupported
}

func (sp *subpath) PrepareSafeSubpath(subPath Subpath) (newHostPath string, cleanupAction func(), err error) {
	handles, err := lockAndCheckSubPath(subPath.VolumePath, subPath.Path)

	// Unlock the directories when the container starts
	cleanupAction = func() {
		unlockPath(handles)
	}
	return subPath.Path, cleanupAction, err
}

// No bind-mounts for subpaths are necessary on Windows