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> lockImmutableTimestamp(UUID requestId, long timestamp) { return heldLocks.getExistingOrAcquire( requestId, () -> acquireImmutableTimestampLock(requestId, timestamp)); }
private AsyncResult<HeldLocks> acquireImmutableTimestampLock(UUID requestId, long timestamp) { AsyncLock immutableTsLock = immutableTsTracker.getLockFor(timestamp); return lockAcquirer.acquireLocks(requestId, OrderedLocks.fromSingleLock(immutableTsLock), TimeLimit.zero()); }
/** * Unlocks if expired, and returns whether the locks are now unlocked (regardless of whether or not they were * unlocked as a result of calling this method). */ public synchronized boolean unlockIfExpired() { if (expirationTimer.isExpired()) { if (unlock()) { lockLog.lockExpired(token.getRequestId(), getLockDescriptors()); } } return isUnlocked; }
private void scheduleTimeout() { if (result.isComplete()) { return; } timeoutExecutor.schedule(() -> timeoutAll(), timeout.getTimeMillis(), TimeUnit.MILLISECONDS); }
private AsyncResult<Void> awaitLocks(UUID requestId, Set<LockDescriptor> lockDescriptors, TimeLimit timeout) { OrderedLocks orderedLocks = locks.getAll(lockDescriptors); return lockAcquirer.waitForLocks(requestId, orderedLocks, timeout); }
private AsyncResult<HeldLocks> acquireLocks(UUID requestId, Set<LockDescriptor> lockDescriptors, TimeLimit timeout) { OrderedLocks orderedLocks = locks.getAll(lockDescriptors); return lockAcquirer.acquireLocks(requestId, orderedLocks, timeout); }
public AsyncResult<Void> waitForLocks(UUID requestId, OrderedLocks locks, TimeLimit timeout) { return new Acquisition(requestId, locks, timeout, lock -> lock.waitUntilAvailable(requestId)) .execute(); }
@Test public void removesRequestIfCompleteSynchronously() { AsyncResult<Void> result = AsyncResult.completedResult(); awaitedLocks.getExistingOrAwait(REQUEST_1, () -> result); assertRequestsWereRemoved(REQUEST_1); }
public AsyncResult<Void> waitForLocks(UUID requestId, Set<LockDescriptor> lockDescriptors, TimeLimit timeout) { return awaitedLocks.getExistingOrAwait( requestId, () -> awaitLocks(requestId, lockDescriptors, timeout)); }
@Override public AsyncResult<Void> lock(UUID requestId) { tracker.lock(timestamp, requestId); return AsyncResult.completedResult(); }
public AsyncResult<LockToken> lock(UUID requestId, Set<LockDescriptor> lockDescriptors, TimeLimit timeout) { return heldLocks.getExistingOrAcquire( requestId, () -> acquireLocks(requestId, lockDescriptors, timeout)); }
@Override public synchronized AsyncResult<Void> waitUntilAvailable(UUID requestId) { return submit(new LockRequest(requestId, true)); }
public void registerRequest(LockRequest request, AsyncResult<?> result) { registerRequest(RequestInfo.of(request), result); }
private void waitUntilAvailableSynchronously(UUID requestId) { waitUntilAvailableAsync(requestId).get(); }
private AsyncResult<LockToken> lock(UUID requestId, String... locks) { return service.lock(requestId, descriptors(locks), TIMEOUT); }
private AsyncResult<Void> waitForLocks(UUID requestId, String... locks) { return service.waitForLocks(requestId, descriptors(locks), TIMEOUT); }
@Override public synchronized AsyncResult<Void> lock(UUID requestId) { return submit(new LockRequest(requestId, false)); }