package org.gradle.caching.internal.controller

import com.google.common.collect.Interner
import org.gradle.caching.BuildCacheEntryReader
import org.gradle.caching.BuildCacheEntryWriter
import org.gradle.caching.BuildCacheKey
import org.gradle.caching.BuildCacheService
import org.gradle.caching.internal.CacheableEntity
import org.gradle.caching.internal.TestBuildCacheKey

            }
        });
    }

    private static class LocalLoadDetails implements BuildCacheLocalLoadBuildOperationType.Details {

        private final BuildCacheKey key;

        public LocalLoadDetails(BuildCacheKey key) {
            this.key = key;
        }

        @Override
        public String getCacheKey() {
            return key.getHashCode();
        }
    }

    Optional<BuildCacheLoadResult> maybeLoad(BuildCacheKey key, File toFile, Function<File, BuildCacheLoadResult> unpackFunction);

    boolean canStore();

    /**
     * Stores the file to the cache.
     *
     * If canStore() returns false, then this method will do nothing and will return false.
     *
     * Returns true if store was completed.
     */
    boolean maybeStore(BuildCacheKey key, File file);

    @Override

    }

    @Override
    public boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException {
        return cache.load(((BuildCacheKeyInternal) key).getHashCodeInternal(), reader::readFrom);
    }

    @Override
    public void loadLocally(BuildCacheKey key, Consumer<? super File> reader) {

        settingsFile << """
            class VisibleNoOpBuildCacheService implements BuildCacheService {
                @Override boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException { false }
                @Override void store(BuildCacheKey key, BuildCacheEntryWriter writer) throws BuildCacheException {}
                @Override void close() throws IOException {}
            }

 *
 * <p>Note that some implementations are mutable and may change behavior over the lifetime of a build.</p>
 */
@ServiceScope(Scope.Gradle.class)
public interface BuildCacheController extends Closeable {

    boolean isEnabled();

    Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity);

package org.gradle.caching.internal.controller.operations;

import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.operations.BuildCacheArchivePackBuildOperationType;

public class PackOperationDetails implements BuildCacheArchivePackBuildOperationType.Details {

    private final BuildCacheKey key;

    public PackOperationDetails(BuildCacheKey key) {
        this.key = key;
    }

    @Override

    public boolean canStore() {
        return pushEnabled;
    }

    @Override
    public boolean maybeStore(BuildCacheKey key, File file) {
        if (canStore()) {
            storeInner(key, file);
            return true;
        }
        return false;
    }

    protected void storeInner(BuildCacheKey key, File file) {
        service.storeLocally(key, file);
    }

    @Override

    @Override
    public Optional<BuildCacheLoadResult> load(BuildCacheKey key, CacheableEntity entity) {
        Optional<BuildCacheLoadResult> result = loadLocal(key, entity);
        if (result.isPresent()) {
            return result;
        }
        return loadRemoteAndStoreResultLocally(key, entity);
    }

    private Optional<BuildCacheLoadResult> loadLocal(BuildCacheKey key, CacheableEntity entity) {
        try {

        buildInvocationId,
        { it.gradleVersion = "3.0" }
    )
    def buildCacheKey = TestHashCodes.hashCodeFrom(1234)

    def "converts to origin metadata"() {
        def origin = new Properties()
        def writer = factory.createWriter("identity", CacheableEntity, buildCacheKey, Duration.ofMillis(10))
        def baos = new ByteArrayOutputStream()
        writer.execute(baos)
        when: