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(

The value is now set via a `Property<LockMode>` instead of a direct setter.
This means that the notation to set the value has to be updated for the Kotlin DSL:

```
dependencyLocking {
    lockMode.set(LockMode.STRICT)
}
```

Users of the Groovy DSL should not be impacted as the notation `lockMode = LockMode.STRICT` remains valid.

        final PersistentCache zincCache = globalScopedCacheBuilderFactory.createCacheBuilder(zincCacheKey)
            .withDisplayName(zincCacheName)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();


        File compilerBridgeJar;
        if (isScala3(scalaVersion)) {
            compilerBridgeJar = findFile("scala3-sbt-bridge", hashedScalaClasspath.getClasspath());

import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.function.Supplier;

import static org.gradle.cache.FileLockManager.LockMode.OnDemand;
import static org.gradle.internal.snapshot.CaseSensitivity.CASE_SENSITIVE;

@SuppressWarnings("MethodMayBeStatic")
class BuildCacheClientModule extends AbstractModule {

        this.keyToSnapshottable = keyToSnapshottable;
        this.timeProvider = timeProvider;
        this.cache = cacheBuilderFactory
            .createCacheBuilder(name)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        IndexedCacheParameters<HashCode, CachedEntry<RESULT>> cacheParams = createCacheConfiguration(name, resultSerializer, cacheDecoratorFactory);

    }

    public FileLock acquireWriteLock(File destinationFile, String operationName) {
        return lockManager.lock(destinationFile, DefaultLockOptions.mode(FileLockManager.LockMode.Exclusive), destinationFile.getName(), operationName);
    }

    public File getDownloadLocation() {
        return jdkDirectory;
    }

    private static String getNameWithoutExtension(File file) {

        store = cacheBuilderFactory.createCacheBuilder("signature-verification")
            .withDisplayName("Signature verification cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        InterningStringSerializer stringSerializer = new InterningStringSerializer(new StringInterner());
        cache = store.createIndexedCache(
            IndexedCacheParameters.of(

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.function.Supplier;

import static org.gradle.cache.FileLockManager.LockMode.Exclusive;

@ThreadSafe
public class DefaultCacheCoordinator implements CacheCreationCoordinator, ExclusiveCacheAccessCoordinator {
    private final static Logger LOG = LoggerFactory.getLogger(DefaultCacheCoordinator.class);

        assertTrue(analysisContext.errorCollector.errors.isEmpty())
    }

    private
    fun importOf(vararg nameParts: String) = Import(AccessChain(listOf(*nameParts)), mockSourceData)

    private
    val mockNode = object : LighterASTNode {
        override fun getTokenType(): IElementType = KtNodeTypes.FUN // whatever, doesn't matter

        override fun getStartOffset(): Int = 0

        override fun getEndOffset(): Int = 0