}

        public void printBlock(String blockSelector, BlockBody blockBody) {
            String indentBefore = indent;

            println(blockSelector + " {");
            indent = indent + "    ";
            needSeparatorLine = false;
            firstStatementOfBlock = true;

            blockBody.writeBodyTo(this);

            indent = indentBefore;
            println("}");

        this.vcsWorkingDirCache = cacheBuilderFactory
            .createCrossVersionCacheBuilder("vcs-1")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .withDisplayName("VCS Checkout Cache")
            .withCleanupStrategy(createCacheCleanupStrategy())
            .open();
    }

    private CacheCleanupStrategy createCacheCleanupStrategy() {

        cache = unscopedCacheBuilderFactory
            .cache(cacheMetaData.getCacheDir())
            .withDisplayName("read only artifact cache")
            .withInitialLockMode(FileLockManager.LockMode.None) // Don't need to lock anything, it's read-only
            .open();
    }

    @Override
    public void close() {
        cache.close();
    }

    @Override

        cache = unscopedCacheBuilderFactory
                .cache(cacheMetaData.getCacheDir())
                .withDisplayName("artifact cache")
                .withInitialLockMode(FileLockManager.LockMode.OnDemand) // Don't need to lock anything until we use the caches
                .withCleanupStrategy(createCacheCleanupStrategy(cacheMetaData, fileAccessTimeJournal, usedGradleVersions, cacheConfigurations))
                .open();

            .createCrossVersionCacheBuilder("buildOutputCleanup")
            .withDisplayName("Build Output Cleanup Cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .withProperties(Collections.singletonMap("gradle.version", GradleVersion.current().getVersion()))
            .open();

    }

    private DefaultComponentMetadataProcessor processorWithCacheThatNeverHits() {
        CacheBuilder cacheBuilder
        cacheBuilder = Mock(CacheBuilder) {
            withInitialLockMode(_ as FileLockManager.LockMode) >> { cacheBuilder }
            open() >> {
                Mock(PersistentCache) {
                    createIndexedCache(_ as IndexedCacheParameters) >> {
                        Mock(IndexedCache) {

                    PersistentCache workerClassPathCache = cacheBuilderFactory
                        .createCacheBuilder("workerMain")
                        .withInitialLockMode(FileLockManager.LockMode.Exclusive)
                        .withInitializer(new CacheInitializer())
                        .open();
                    try {

        BuildCommencedTimeProvider timeProvider,
        boolean refreshKeys) {
        cache = cacheBuilderFactory
            .createCrossVersionCacheBuilder("keyrings")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        this.buildOperationRunner = buildOperationRunner;
        this.delegate = delegate;
        this.timeProvider = timeProvider;
        this.refreshKeys = refreshKeys;

    private
    val cache = cacheBuilderFactory
        .createCrossVersionCacheBuilder("configuration-cache")
        .withDisplayName("Configuration Cache")
        .withInitialLockMode(FileLockManager.LockMode.OnDemand) // Don't need to lock anything until we use the caches
        .withLruCacheCleanup()
        .open()

    private
    fun CacheBuilder.withLruCacheCleanup(): CacheBuilder =
        withCleanupStrategy(

				Local: &v1.LocalVolumeSource{
					Path: path,
				},
			},
			MountOptions: mountOptions,
		},
	}

	if isBlock {
		blockMode := v1.PersistentVolumeBlock
		pv.Spec.VolumeMode = &blockMode
	} else {
		fsMode := v1.PersistentVolumeFilesystem
		pv.Spec.VolumeMode = &fsMode
	}
	return volume.NewSpecFromPersistentVolume(pv, readOnly)
}