*/
package org.gradle.cache;

import java.util.concurrent.Callable;
import java.util.function.Supplier;

/**
 * Provides synchronization with other processes for a particular file.
 */
public interface FileAccess {
    /**
     * Runs the given action under a shared or exclusive lock on the target file.
     *
     * @throws LockTimeoutException On timeout acquiring lock, if required.

 * limitations under the License.
 */
package org.gradle.cache.internal

import org.gradle.cache.FileAccess
import org.gradle.cache.internal.btree.BTreePersistentIndexedCache
import spock.lang.Specification

import java.util.function.Supplier

class MultiProcessSafeIndexedCacheTest extends Specification {
    final FileAccess fileAccess = Mock()
    final Supplier<BTreePersistentIndexedCache<String, String>> factory = Mock()

    final FileAccess fileAccess = Mock()
    final Chmod chmod = Mock()
    final File file = tmpDir.file("state.bin")
    final FileBackedObjectHolder<String> cache = createStateCache(fileAccess)

    private FileBackedObjectHolder createStateCache(FileAccess fileAccess, File file = file, Serializer serializer = new DefaultSerializer()) {

    private final FileAccess fileAccess;
    private final Supplier<BTreePersistentIndexedCache<K, V>> factory;
    private BTreePersistentIndexedCache<K, V> cache;

    public DefaultMultiProcessSafeIndexedCache(Supplier<BTreePersistentIndexedCache<K, V>> factory, FileAccess fileAccess) {
        this.factory = factory;
        this.fileAccess = fileAccess;
    }

    @Override

    private final FileAccess fileAccess;
    private final Serializer<T> serializer;
    private final Chmod chmod;
    private final File cacheFile;

    public FileBackedObjectHolder(File cacheFile, FileAccess fileAccess, Serializer<T> serializer, Chmod chmod) {
        this.cacheFile = cacheFile;
        this.fileAccess = fileAccess;
        this.serializer = serializer;
        this.chmod = chmod;

package org.gradle.cache.internal;

import org.gradle.cache.FileAccess;
import org.gradle.cache.FileIntegrityViolationException;
import org.gradle.cache.LockTimeoutException;

import java.util.concurrent.Callable;
import java.util.function.Supplier;

import static org.gradle.internal.UncheckedException.uncheckedCall;

public abstract class AbstractFileAccess implements FileAccess {
    @Override

    private final String cacheDisplayName;
    private final File baseDir;
    private final CacheCleanupExecutor cleanupAction;
    private final ExecutorFactory executorFactory;
    private final FileAccess fileAccess;
    private final Map<String, IndexedCacheEntry<?, ?>> caches = new HashMap<>();
    private final AbstractCrossProcessCacheAccess crossProcessCacheAccess;
    private final CacheAccessOperationsStack operations;

        Assume.assumeFalse("cannot use the file APIs in restricted DSL", isRestrictedDsl())

        def configurationCache = newConfigurationCacheFixture()

        UndeclaredFileAccess access = fileAccess(testDirectory)
        buildLogicApplication(access)
        def accessedFile = new File(access.filePath)

        when: "an empty directory used in configuration is created"
        assert accessedFile.mkdirs()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.cache.internal

import org.gradle.cache.FileAccess
import org.gradle.cache.FileIntegrityViolationException
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.internal.filelock.DefaultLockOptions

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache.internal

import org.gradle.cache.FileAccess
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.FileLockManager.LockMode
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule