private final BuildCacheKey key;
        private final Throwable e;
        private final BuildCacheOperationType operationType;

        public RemoteDisabledDueToFailureProgressDetails(BuildCacheKey key, Throwable e, BuildCacheOperationType operationType) {
            this.key = key;
            this.e = e;

    }

    @Override
    public Optional<BuildCacheLoadResult> maybeLoad(BuildCacheKey key, Function<File, BuildCacheLoadResult> unpackFunction) {
        return Optional.empty();
    }

    @Override
    public boolean canStore() {
        return false;
    }

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

    @Override

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

public class UnpackOperationDetails implements BuildCacheArchiveUnpackBuildOperationType.Details {

    private final BuildCacheKey key;
    private final long archiveSize;

    public UnpackOperationDetails(BuildCacheKey key, long archiveSize) {
        this.key = key;

 * limitations under the License.
 */

package org.gradle.internal.execution.steps;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSortedMap;
import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.CacheableEntity;
import org.gradle.caching.internal.controller.BuildCacheController;
import org.gradle.caching.internal.controller.service.BuildCacheLoadResult;

        def thirdBuildCacheKey = buildCacheKey(":write")
        thirdBuildCacheKey != firstBuildCacheKey
        thirdBuildCacheKey != null
        originBuildInvocationId(":write") == null

        when:
        succeeds "write"

        then:
        executed ":write"
        with(origin(":write")) {
            buildInvocationId == thirdBuildId
            buildCacheKey == thirdBuildCacheKey
        }
    }

     * Loads a cache artifact from a local file store. If a result is found the {@code reader} is executed.
     */
    void loadLocally(BuildCacheKey key, Consumer<? super File> reader);

    /**
     * Store the given file in the local file store as a cache artifact.
     */
    void storeLocally(BuildCacheKey key, File file);

                        def buildCacheKey = buildCacheKeysByParentId.remove(buildOperation.id.id)
                        if (buildCacheKey != null) {
                            buildCacheKeys.put(buildOperation.details.task.getIdentityPath(), buildCacheKey)
                        }
                    }

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

    boolean canStore();

    /**
     * Stores the file to the local 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
    public Optional<BuildCacheLoadResult> maybeLoad(BuildCacheKey key, File toFile, Function<File, BuildCacheLoadResult> unpackFunction) {
        return Optional.empty();
    }

    @Override
    public boolean canStore() {
        return false;
    }

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

    @Override

    @Override
    public boolean isEnabled() {
        return false;
    }

    @Override
    public Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity) {
        return Optional.empty();
    }

    @Override
    public void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime) {

    }

    @Override