Optional<ArtifactCacheMetadata> getReadOnlyCacheMetadata();

    ArtifactCacheLockingAccessCoordinator getWritableCacheAccessCoordinator();
    Optional<ArtifactCacheLockingAccessCoordinator> getReadOnlyCacheAccessCoordinator();

    default <T> T withWritableCache(BiFunction<? super ArtifactCacheMetadata, ? super ArtifactCacheLockingAccessCoordinator, T> function) {

class DefaultModuleArtifactCacheTest extends Specification {

    @Rule TestNameTestDirectoryProvider folder = new TestNameTestDirectoryProvider(getClass())

    ArtifactCacheLockingAccessCoordinator cacheAccessCoordinator = Mock(ArtifactCacheLockingAccessCoordinator)
    BuildCommencedTimeProvider timeProvider = Mock(BuildCommencedTimeProvider)
    IndexedCache persistentIndexedCache = Mock(IndexedCache)

import org.gradle.internal.serialize.Serializer
import org.gradle.testfixtures.internal.TestInMemoryIndexedCache

import java.util.function.Supplier

class ArtifactCacheLockingAccessCoordinatorStub implements ArtifactCacheLockingAccessCoordinator {
    private final Map<String, IndexedCache<?, ?>> caches = [:]

    IndexedCache<?, ?> getCache(String cacheName) {
        caches[cacheName]
    }

    @Override

 */

package org.gradle.api.internal.artifacts;

import com.google.common.collect.ImmutableMap;
import org.gradle.StartParameter;
import org.gradle.api.internal.artifacts.ivyservice.ArtifactCacheLockingAccessCoordinator;
import org.gradle.api.internal.artifacts.ivyservice.ArtifactCacheMetadata;
import org.gradle.api.internal.artifacts.ivyservice.ArtifactCachesProvider;

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.services

import org.gradle.api.internal.artifacts.ivyservice.ArtifactCacheLockingAccessCoordinator
import org.gradle.api.internal.file.temp.TemporaryFileProvider
import org.gradle.internal.cc.impl.initialization.ConfigurationCacheStartParameter
import org.gradle.internal.resource.ExternalResourceName

 * limitations under the License.
 */

package org.gradle.internal.resource.transport;

import org.gradle.api.internal.artifacts.ivyservice.ArtifactCacheLockingAccessCoordinator;
import org.gradle.api.internal.artifacts.ivyservice.resolutionstrategy.ExternalResourceCachePolicy;
import org.gradle.api.internal.file.temp.TemporaryFileProvider;
import org.gradle.cache.internal.ProducerGuard;

package org.gradle.api.internal.artifacts.repositories.transport;

import org.gradle.api.InvalidUserDataException;
import org.gradle.api.credentials.Credentials;
import org.gradle.api.internal.artifacts.ivyservice.ArtifactCacheLockingAccessCoordinator;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.StartParameterResolutionOverride;
import org.gradle.api.internal.artifacts.ivyservice.resolutionstrategy.DefaultExternalResourceCachePolicy;

        return Optional.ofNullable(readOnlyCacheMetadata);
    }

    @Override
    public ArtifactCacheLockingAccessCoordinator getWritableCacheAccessCoordinator() {
        return writableCacheAccessCoordinator;
    }

    @Override
    public Optional<ArtifactCacheLockingAccessCoordinator> getReadOnlyCacheAccessCoordinator() {
        return Optional.ofNullable(readOnlyCacheAccessCoordinator);
    }

    def "retry for metadata directory creation issue in Gradle 1.9 or 1.10"() {
        given:
        iteration++

        when:
        throwWhen(new ServiceCreationException("Could not create service of type ArtifactCacheLockingAccessCoordinator using DependencyManagementBuildScopeServices.createArtifactCacheLockingManager().",
            new UncheckedIOException("Unable to create directory 'metadata-2.1'")), iteration == 1)

        then:
        true

 * write operations use the regular locking mechanism (file or in-process).
 */
public class ReadOnlyArtifactCacheLockingAccessCoordinator implements ArtifactCacheLockingAccessCoordinator, Closeable {
    private final static Logger LOGGER = Logging.getLogger(ReadOnlyArtifactCacheLockingAccessCoordinator.class);

    private final PersistentCache cache;