@Override public void close() throws IOException { lockService.close(); } }
@Test public void canLockAndUnlockImmutableTimestamp() { long timestamp = 123L; LockToken token = service.lockImmutableTimestamp(REQUEST_1, timestamp).get(); assertThat(service.getImmutableTimestamp().get()).isEqualTo(123L); service.unlock(token); assertThat(service.getImmutableTimestamp()).isEqualTo(Optional.empty()); }
@Test public void doesNotAcquireDuplicateRequests() { Set<LockDescriptor> descriptors = descriptors(LOCK_A); lockService.lock(REQUEST_ID, descriptors, DEADLINE); lockService.lock(REQUEST_ID, descriptors, DEADLINE); verify(acquirer, times(1)).acquireLocks(any(), any(), any()); verifyNoMoreInteractions(acquirer); }
@Override public LockImmutableTimestampResponse lockImmutableTimestamp(IdentifiedTimeLockRequest request) { long timestamp = timestampService.getFreshTimestamp(); // this will always return synchronously LockToken token = lockService.lockImmutableTimestamp(request.getRequestId(), timestamp).get(); long immutableTs = lockService.getImmutableTimestamp().orElse(timestamp); return LockImmutableTimestampResponse.of(immutableTs, token); }
@Override public Set<LockToken> unlock(Set<LockToken> tokens) { return lockService.unlock(tokens); }
@Test public void waitForLocksRequestsAreIdempotent() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> request = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); AsyncResult<Void> duplicate = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); assertThat(request).isEqualTo(duplicate); service.unlock(token); assertThat(request.isCompletedSuccessfully()).isTrue(); assertThat(duplicate.isCompletedSuccessfully()).isTrue(); }
private AsyncResult<Void> waitForLocks(UUID requestId, String... locks) { return service.waitForLocks(requestId, descriptors(locks), TIMEOUT); }
@Test @ShouldRetry public void timedOutRequestDoesNotHoldLocks() { LockToken lockBToken = lockSynchronously(REQUEST_1, LOCK_B); service.lock(REQUEST_2, descriptors(LOCK_A, LOCK_B), SHORT_TIMEOUT); waitForTimeout(SHORT_TIMEOUT); assertNotLocked(LOCK_A); service.unlock(lockBToken); assertNotLocked(LOCK_B); }
@Override public Set<LockToken> refreshLockLeases(Set<LockToken> tokens) { return lockService.refresh(tokens); }
@Override public long getImmutableTimestamp() { long timestamp = timestampService.getFreshTimestamp(); return lockService.getImmutableTimestamp().orElse(timestamp); }
@Test public void delegatesImmutableTimestampRequestsToTracker() { UUID requestId = UUID.randomUUID(); long timestamp = 123L; AsyncLock immutableTsLock = spy(newLock()); when(immutableTimestampTracker.getLockFor(timestamp)).thenReturn(immutableTsLock); lockService.lockImmutableTimestamp(requestId, timestamp); verify(acquirer).acquireLocks(requestId, orderedLocks(immutableTsLock), TimeLimit.zero()); }
public AsyncResult<LockToken> lockImmutableTimestamp(UUID requestId, long timestamp) { return heldLocks.getExistingOrAcquire( requestId, () -> acquireImmutableTimestampLock(requestId, timestamp)); }
public static AsyncLockService createDefault( LockLog lockLog, ScheduledExecutorService reaperExecutor, ScheduledExecutorService timeoutExecutor) { return new AsyncLockService( new LockCollection(), new ImmutableTimestampTracker(), new LockAcquirer(lockLog, timeoutExecutor), new HeldLocksCollection(), new AwaitedLocksCollection(), reaperExecutor); }
public AsyncResult<LockToken> lock(UUID requestId, Set<LockDescriptor> lockDescriptors, TimeLimit timeout) { return heldLocks.getExistingOrAcquire( requestId, () -> acquireLocks(requestId, lockDescriptors, timeout)); }
public boolean unlock(LockToken token) { return unlock(ImmutableSet.of(token)).contains(token); }
@Override public LockImmutableTimestampResponse lockImmutableTimestamp(IdentifiedTimeLockRequest request) { long timestamp = timestampService.getFreshTimestamp(); // this will always return synchronously LockToken token = lockService.lockImmutableTimestamp(request.getRequestId(), timestamp).get(); long immutableTs = lockService.getImmutableTimestamp().orElse(timestamp); return LockImmutableTimestampResponse.of(immutableTs, token); }
@Test public void doesNotWaitForDuplicateRequests() { Set<LockDescriptor> descriptors = descriptors(LOCK_A); lockService.waitForLocks(REQUEST_ID, descriptors, DEADLINE); lockService.waitForLocks(REQUEST_ID, descriptors, DEADLINE); verify(acquirer, times(1)).waitForLocks(any(), any(), any()); verifyNoMoreInteractions(acquirer); }
public boolean refresh(LockToken token) { return refresh(ImmutableSet.of(token)).contains(token); }