/** * Tests the provided predicate against the value of this result, if it has completed successfully. If it has * not yet completed, or has failed or timed out, the predicate is not executed and {@code false} is returned. */ public boolean test(Predicate<T> predicateIfCompletedSuccessfully) { if (isCompletedSuccessfully()) { return predicateIfCompletedSuccessfully.test(get()); } return false; }
@POST @Path("lock") public void lock(@Suspended final AsyncResponse response, LockRequest request) { AsyncResult<LockToken> result = timelock.lock(request); lockLog.registerRequest(request, result); result.onComplete(() -> { if (result.isFailed()) { response.resume(result.getError()); } else if (result.isTimedOut()) { response.resume(LockResponse.timedOut()); } else { response.resume(LockResponse.successful(result.get())); } }); }
private void waitUntilAvailableSynchronously(UUID requestId) { waitUntilAvailableAsync(requestId).get(); }
@POST @Path("lock") public void lock(@Suspended final AsyncResponse response, LockRequest request) { AsyncResult<LockToken> result = timelock.lock(request); lockLog.registerRequest(request, result); result.onComplete(() -> { if (result.isFailed()) { response.resume(result.getError()); } else if (result.isTimedOut()) { response.resume(LockResponse.timedOut()); } else { response.resume(LockResponse.successful(result.get())); } }); }
private void lockSynchronously(UUID requestId) { lock.lock(requestId).get(); }
private LockToken lockSynchronously(UUID requestId, String... locks) { return lock(requestId, locks).get(); }
@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 requestsAreIdempotentDuringAcquisitionPhase() { LockToken currentHolder = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> tokenResult = lock(REQUEST_2, LOCK_A); AsyncResult<LockToken> duplicateResult = lock(REQUEST_2, LOCK_A); service.unlock(currentHolder); assertThat(tokenResult.isCompletedSuccessfully()).isTrue(); assertThat(duplicateResult.isCompletedSuccessfully()).isTrue(); assertThat(tokenResult.get()).isEqualTo(duplicateResult.get()); }
@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 returnsCorrectlyConfiguredHeldLocks() throws Exception { HeldLocks heldLocks = acquire(lockA, lockB).get(); assertThat(heldLocks.getLocks()).contains(lockA, lockB); assertThat(heldLocks.getRequestId()).isEqualTo(REQUEST_ID); }
/** * Tests the provided predicate against the value of this result, if it has completed successfully. If it has * not yet completed, or has failed or timed out, the predicate is not executed and {@code false} is returned. */ public boolean test(Predicate<T> predicateIfCompletedSuccessfully) { if (isCompletedSuccessfully()) { return predicateIfCompletedSuccessfully.test(get()); } return false; }
@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); }