// files as needed, as the resources change.
type Cache struct {
	mu sync.Mutex

	discriminator int64
	resources     map[CacheKey]*resourceState
	dir           string
}

// CacheKey is a key representing a tracked Yaml based resource.
type CacheKey struct {
	group     string
	kind      string
	namespace string
	name      string
}

type resourceState struct {
	part Part
	file string

    }

    void deleteCacheEntry(String cacheKey) {
        def entry = getTestFileCacheEntry(cacheKey)
        if (entry.file.exists()) {
            entry.file.deleteDir()
        }
    }

    boolean hasCacheEntry(String cacheKey) {
        return getTestFileCacheEntry(cacheKey).file.exists()
    }

    TestCacheEntry getCacheEntry(String cacheKey) {
        def cacheEntry = getTestFileCacheEntry(cacheKey)

        """
        succeeds("customTask")

        then:
        def cacheKey = cacheOperations.getCacheKeyForTask(":customTask")
        remoteCache.hasCacheEntry(cacheKey)

        when:
        def cacheEntry = remoteCache.getCacheEntry(cacheKey)
        cacheEntry.text = "corrupt"
        localCache.deleteCacheEntry(cacheKey)

        then:
        fails("clean", "customTask")

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);
    }

    public PluginDescriptor get(Key cacheKey) {
        return clone(descriptors.get(cacheKey));
    }

    @Override
    public PluginDescriptor get(Key key, PluginDescriptorSupplier supplier)

        public boolean equals(Object o) {
            if (o == this) {
                return true;
            }

            if (!(o instanceof CacheKey)) {
                return false;
            }

            CacheKey that = (CacheKey) o;

            return CacheUtils.pluginEquals(plugin, that.plugin)
                    && Objects.equals(workspace, that.workspace)

                return false;
            }
            CacheKey cacheKey = (CacheKey) o;
            return Objects.equal(backingStateType, cacheKey.backingStateType)
                && Objects.equal(schema, cacheKey.schema)
                && Objects.equal(structBindings.getDelegateSchema(), cacheKey.structBindings.getDelegateSchema());
        }

        @Override
        public int hashCode() {

    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final List<File> files;

        private final List<Long> timestamps;

        private final List<Long> sizes;

        private final List<String> ids;

        private final int hashCode;

        public CacheKey(List<Artifact> extensionArtifacts) {

        String cacheKey = versionCacheKey(repository, version);
        return checkoutDirs.get(cacheKey);
    }

    public void putWorkingDirForRevision(VersionControlRepositoryConnection repository, VersionRef version, File dir) {
        String cacheKey = versionCacheKey(repository, version);
        checkoutDirs.put(cacheKey, dir);
    }

    @Nullable

    private final OriginMetadata originMetadata;
    private final boolean successful;
    private final HashCode cacheKey;

    public DefaultPreviousExecutionState(
        OriginMetadata originMetadata,
        HashCode cacheKey,
        ImplementationSnapshot implementation,
        ImmutableList<ImplementationSnapshot> additionalImplementations,

    private final BuildCacheKey cacheKey;
    private final long archiveSize;

    public StoreOperationDetails(BuildCacheKey cacheKey, long archiveSize) {
        this.cacheKey = cacheKey;
        this.archiveSize = archiveSize;
    }

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

    @Override
    public long getArchiveSize() {