*/
package org.gradle.cache;

import java.io.File;

/**
 * Thrown on timeout acquiring a lock on a file.
 */
public class LockTimeoutException extends RuntimeException {
    private final File lockFile;

    public LockTimeoutException(String message, File lockFile) {
        super(message);
        this.lockFile = lockFile;
    }

    public File getLockFile() {
        return lockFile;

     */
    <T> T readFile(Callable<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException, InsufficientLockModeException;

    /**
     * Runs the given action under a shared or exclusive lock on the target file.
     *
     * @throws LockTimeoutException On timeout acquiring lock, if required.
     * @throws IllegalStateException When this lock has been closed.

        FileLock lock = manager.lock(targetFile, mode(FileLockManager.LockMode.Exclusive), displayName);
        try {
            lock.updateFile(action);
        } finally {
            lock.close();
        }
    }

    @Override
    public void writeFile(Runnable action) throws LockTimeoutException {

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
    public <T> T readFile(final Callable<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException {

     * @param targetDisplayName A display name for the target file. This is used in log and error messages.
     */
    FileLock lock(File target, LockOptions options, String targetDisplayName) throws LockTimeoutException;

    /**
     * Creates a lock for the given file with the given mode. Acquires a lock with the given mode, which is held until the lock is

        }

        @Override
        public <T> T readFile(Supplier<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException, InsufficientLockModeException {
            return action.get();
        }

        @Override
        public void updateFile(Runnable action) throws LockTimeoutException, FileIntegrityViolationException, InsufficientLockModeException {
            action.run();
        }

        }

        @Override
        public <T> T readFile(Supplier<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException {
            assertOpenAndIntegral();
            return action.get();
        }

        @Override
        public void updateFile(Runnable action) throws LockTimeoutException, FileIntegrityViolationException {
            assertOpenAndIntegral();
            doWriteAction(action);

 */

package org.gradle.cache.internal

import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.FileLockReleasedSignal
import org.gradle.cache.LockTimeoutException
import org.gradle.cache.internal.filelock.DefaultLockOptions
import org.gradle.cache.internal.locklistener.DefaultFileLockContentionHandler
import org.gradle.cache.internal.locklistener.FileLockContentionHandler