private void scheduleTimeout() { if (result.isComplete()) { return; } timeoutExecutor.schedule(() -> timeoutAll(), timeout.getTimeMillis(), TimeUnit.MILLISECONDS); }
@Test public void multipleQueuedRequestsCanObtainLock() { lockSynchronously(REQUEST_1); AsyncResult<Void> result2 = lockAsync(REQUEST_2); AsyncResult<Void> result3 = lockAsync(REQUEST_3); unlock(REQUEST_1); assertThat(result2.isCompletedSuccessfully()).isTrue(); assertThat(result3.isComplete()).isFalse(); unlock(REQUEST_2); assertThat(result3.isCompletedSuccessfully()).isTrue(); }
@Test public void waitUntilAvailableWantsUntilLockIsFree() { lockSynchronously(REQUEST_1); AsyncResult<Void> result = waitUntilAvailableAsync(REQUEST_2); assertThat(result.isComplete()).isFalse(); unlock(REQUEST_1); assertThat(result.isCompletedSuccessfully()).isTrue(); }
private void registerRequest(RequestInfo requestInfo, AsyncResult<?> result) { if (result.isComplete()) { requestComplete(requestInfo, result, 0L); return; } long start = System.currentTimeMillis(); result.onComplete(() -> { long durationMillis = System.currentTimeMillis() - start; requestComplete(requestInfo, result, durationMillis); }); }
@Test public void waitingRequestGetsTheLockAfterItIsUnlocked() { LockToken request1 = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A); assertThat(request2.isComplete()).isFalse(); service.unlock(request1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void lockIsExclusive() { lockSynchronously(REQUEST_1); AsyncResult<Void> result = lockAsync(REQUEST_2); assertThat(result.isComplete()).isFalse(); }
@Test public void waitingRequestGetsTheLockAfterItIsUnlockedWithMultipleLocks() { LockToken request1 = lockSynchronously(REQUEST_1, LOCK_A, LOCK_C); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A, LOCK_B, LOCK_C, LOCK_D); assertThat(request2.isComplete()).isFalse(); service.unlock(request1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void waitUntilAvailableCompletesSynchronouslyIfAvailable() { AsyncResult<Void> result = lock.waitUntilAvailable(REQUEST_1); assertTrue(result.isComplete()); }
@Test public void unlockByWaiterNoOps() { lockSynchronously(REQUEST_1); AsyncResult<Void> request2 = lockAsync(REQUEST_2); unlock(REQUEST_2); assertThat(lock.getCurrentHolder()).isEqualTo(REQUEST_1); assertThat(request2.isComplete()).isFalse(); // request2 should still get the lock when it's available unlock(REQUEST_1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void lockIsAcquiredSynchronouslyIfAvailable() { AsyncResult<Void> result = lock.lock(REQUEST_1); assertTrue(result.isComplete()); }
@Test public void waitUntilAvailableDoesNotBlockLockRequests() { lockSynchronously(REQUEST_1); waitUntilAvailableAsync(REQUEST_2); AsyncResult<Void> lockRequest = lockAsync(REQUEST_3); assertThat(lockRequest.isComplete()).isFalse(); unlock(REQUEST_1); assertThat(lockRequest.isCompletedSuccessfully()).isTrue(); }
private void assertLocked(String... locks) { AsyncResult<LockToken> result = lock(UUID.randomUUID(), locks); assertFalse(result.isComplete()); result.map(token -> service.unlock(token)); }
@Test public void canWaitForLock() { LockToken lockAHolder = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> waitResult = waitForLocks(REQUEST_2, LOCK_A); assertThat(waitResult.isComplete()).isFalse(); service.unlock(lockAHolder); assertThat(waitResult.isCompletedSuccessfully()).isTrue(); assertNotLocked(LOCK_A); }
private void scheduleTimeout() { if (result.isComplete()) { return; } timeoutExecutor.schedule(() -> timeoutAll(), timeout.getTimeMillis(), TimeUnit.MILLISECONDS); }
@Test public void timeoutDoesNothingIfLockIsAlreadyAcquired() { lockSynchronously(REQUEST_1); lock.timeout(REQUEST_1); // lock should still be locked, and able to be unlocked AsyncResult<Void> request2 = lockAsync(REQUEST_2); assertThat(request2.isComplete()).isFalse(); unlock(REQUEST_1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
private void registerRequest(RequestInfo requestInfo, AsyncResult<?> result) { if (result.isComplete()) { requestComplete(requestInfo, result, 0L); return; } long start = System.currentTimeMillis(); result.onComplete(() -> { long durationMillis = System.currentTimeMillis() - start; requestComplete(requestInfo, result, durationMillis); }); }
@Test public void canWaitForMultipleLocks() { LockToken lockAHolder = lockSynchronously(REQUEST_1, LOCK_B, LOCK_C); AsyncResult<Void> waitResult = waitForLocks(REQUEST_2, LOCK_A, LOCK_B, LOCK_C); assertThat(waitResult.isComplete()).isFalse(); assertNotLocked(LOCK_A); service.unlock(lockAHolder); assertThat(waitResult.isCompletedSuccessfully()).isTrue(); assertNotLocked(LOCK_A); assertNotLocked(LOCK_C); }
@Test public void queuesAcquisitionsForHeldLocks() { lockA.lock(OTHER_REQUEST_ID); lockB.lock(OTHER_REQUEST_ID); AsyncResult<HeldLocks> acquisitions = acquire(lockA, lockB); lockA.unlock(OTHER_REQUEST_ID); assertFalse(acquisitions.isComplete()); lockB.unlock(OTHER_REQUEST_ID); assertThat(acquisitions.isCompletedSuccessfully()).isTrue(); }