int port = handler.reservePort();
        handler.start(15, { executed.set(true) })
        client.maybePingOwner(port, 15, "lock", 50000, null)
        poll { assert executed.get() }
    }

    def "reserving port is safely reentrant"() {
        when:
        int port = handler.reservePort()

        then:
        handler.reservePort() == port
    }

        return ImmutableList.copyOf(reservations)
    }

    @Override
    public int assignPort() {
        try {
            lock.lock()
            return reservePort()
        } finally {
            lock.unlock()
        }
    }

    @Override
    public void releasePort(int port) {
        if (port == null || port < MIN_PRIVATE_PORT || port > MAX_PRIVATE_PORT) {

    @Override
    public void start(long lockId, Consumer<FileLockReleasedSignal> whenContended) {}

    @Override
    public void stop(long lockId) {}

    @Override
    public int reservePort() {
        return -1;
    }

    @Override
    public boolean maybePingOwner(int port, long lockId, String displayName, long timeElapsed, FileLockReleasedSignal signal) {
        return false;
    }

@ServiceScope(Scope.Global.class)
public interface FileLockContentionHandler {
    void start(long lockId, Consumer<FileLockReleasedSignal> whenContended);

    void stop(long lockId);

    int reservePort();

    /**
     * Pings the lock owner with the give port to start the lock releasing
     * process in the owner. May not ping the owner if:

        testDirLock = tmpDir.file("${testDir.name}/${testDir.name}.lock")

        metaDataProvider.processIdentifier >> '123'
        metaDataProvider.processDisplayName >> 'process'
        contentionHandler.reservePort() >> 34
        generator.asLong >> 678L
    }

    def cleanup() {
        CompositeStoppable.stoppable(openedLocks.toArray()).stop()
    }

            fileLockRequestListener.stop();
        }
        if (unlockActionExecutor != null) {
            unlockActionExecutor.stop();
        }
    }

    @Override
    public int reservePort() {
        return getCommunicator().getPort();
    }

    private FileLockCommunicator getCommunicator() {
        lock.lock();
        try {
            assertNotStopped();

            throw new IllegalStateException(String.format("Cannot lock %s as it has already been locked by this process.", targetDisplayName));
        }
        try {
            int port = fileLockContentionHandler.reservePort();
            return new DefaultFileLock(canonicalTarget, options, targetDisplayName, operationDisplayName, port, whenContended);
        } catch (Throwable t) {
            lockedFiles.remove(canonicalTarget);