private com.palantir.lock.LockRequest toLegacyWaitForLocksRequest(Set<LockDescriptor> lockDescriptors) { SortedMap<LockDescriptor, LockMode> locks = buildLockMap(lockDescriptors, LockMode.READ); return com.palantir.lock.LockRequest.builder(locks).lockAndRelease().build(); }
public static LockRefreshingRemoteLockService create(RemoteLockService delegate) { final LockRefreshingRemoteLockService ret = new LockRefreshingRemoteLockService(delegate); ret.exec.scheduleWithFixedDelay(() -> { long startTime = System.currentTimeMillis(); try { ret.refreshLocks(); } catch (Throwable t) { log.warn("Failed to refresh locks", t); } finally { long elapsed = System.currentTimeMillis() - startTime; if (elapsed > LockRequest.getDefaultLockTimeout().toMillis() / 2) { log.warn("Refreshing locks took {} milliseconds" + " for tokens: {}", elapsed, ret.toRefresh); } else if (elapsed > ret.refreshFrequencyMillis) { log.info("Refreshing locks took {} milliseconds" + " for tokens: {}", elapsed, ret.toRefresh); } } }, 0, ret.refreshFrequencyMillis, TimeUnit.MILLISECONDS); return ret; }
private LockRefreshToken lock(LockClient client, LockRequest request) throws InterruptedException { if (request.getBlockingMode() == BlockingMode.DO_NOT_BLOCK) { if (client == LockClient.ANONYMOUS) { return nonBlockingClient.lock(LockClient.ANONYMOUS.getClientId(), request); if ((request.getLockGroupBehavior() == LockGroupBehavior.LOCK_ALL_OR_NONE) && (request.getBlockingMode() != BlockingMode.BLOCK_INDEFINITELY_THEN_RELEASE)) { LockRequest.Builder newRequest = LockRequest.builder(request.getLockDescriptors()); newRequest.doNotBlock(); newRequest.timeoutAfter(request.getLockTimeout()); if (request.getVersionId() != null) { newRequest.withLockedInVersionId(request.getVersionId());
/** * Builds a {@link LockRequest} instance. After calling this method, the * builder object is invalidated. */ public LockRequest build() { if ((lockMap == null) || ((blockingMode == null) && (lockGroupBehavior != null))) { throw new IllegalStateException(); } if (versionId != null && blockingMode == BlockingMode.BLOCK_INDEFINITELY_THEN_RELEASE) { throw new IllegalStateException(); } String serverName = ""; if (!localServerName.isEmpty()) { serverName = " (on server " + localServerName + ")"; } LockRequest request = new LockRequest(lockMap, MoreObjects.firstNonNull(lockTimeout, getDefaultLockTimeout()), MoreObjects.firstNonNull(lockGroupBehavior, LockGroupBehavior.LOCK_ALL_OR_NONE), MoreObjects.firstNonNull(blockingMode, BlockingMode.BLOCK_INDEFINITELY), blockingDuration, versionId, MoreObjects.firstNonNull(creatingThreadName, Thread.currentThread().getName()) + serverName); lockMap = null; return request; }
public static SimpleLockRequest of(LockRequest request, String lockDescriptor, LockMode lockMode, String clientId) { return ImmutableSimpleLockRequest.builder() .lockDescriptor(lockDescriptor) .lockMode(lockMode) .lockCount(request.getLocks().size()) .lockTimeout(request.getLockTimeout().toMillis()) .lockGroupBehavior(request.getLockGroupBehavior()) .blockingMode(request.getBlockingMode()) .blockingDuration(extractBlockingDurationOrNull(request.getBlockingDuration())) .versionId(request.getVersionId()) .creatingThread(request.getCreatingThreadName()) .clientId(clientId).build(); }
long lockTimeoutMs = LockRequest.getDefaultLockTimeout().toMillis(); LockRequest request1 = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.READ)) .doNotBlock().build(); long currentTimeMs = System.currentTimeMillis(); Assert.assertNotNull(token1); Assert.assertEquals(LockClient.ANONYMOUS, token1.getClient()); Assert.assertEquals(request1.getLockDescriptors(), token1.getLockDescriptors()); Assert.assertTrue(currentTimeMs + lockTimeoutMs <= token1.getExpirationDateMs()); Assert.assertTrue(token1.getExpirationDateMs() LockRequest request2 = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE)).build(); LockResponse response2 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request2); HeldLocksToken validToken = response2.getToken();
/** Convert a write lock to a read lock */ @Test public void testConvertWriteToRead() throws Exception { final LockRequest request1 = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE)) .build(); final LockRequest request2 = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.READ)) .build(); HeldLocksToken token1 = server.lockWithFullLockResponse(client, request1).getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); Assert.assertEquals(request1.getLockDescriptors(), token1.getLockDescriptors()); Future<?> future = executor.submit((Callable<Void>) () -> { barrier.await(); HeldLocksToken validToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request2).getToken(); Assert.assertNotNull(validToken); Assert.assertEquals(LockClient.ANONYMOUS, validToken.getClient()); Assert.assertEquals(request2.getLockDescriptors(), validToken.getLockDescriptors()); Assert.assertTrue(server.unlock(validToken)); return null; }); barrier.await(); Thread.sleep(50); HeldLocksToken token2 = server.lockWithFullLockResponse(client, request2).getToken(); Assert.assertNotNull(token2); Assert.assertEquals(client, token2.getClient()); Assert.assertEquals(request2.getLockDescriptors(), token2.getLockDescriptors()); Assert.assertTrue(server.unlock(token1)); future.get(); Assert.assertTrue(server.unlock(token2)); Assert.assertTrue(server.getTokens(client).isEmpty()); }
Preconditions.checkNotNull(client); Preconditions.checkArgument(!client.equals(INTERNAL_LOCK_GRANT_CLIENT)); Preconditions.checkArgument(request.getLockTimeout().compareTo(maxAllowedLockTimeout) <= 0, "Requested lock timeout (%s) is greater than maximum allowed lock timeout (%s)", request.getLockTimeout(), maxAllowedLockTimeout); requestLogger.debug("LockServiceImpl processing lock request {} for requesting thread {}", UnsafeArg.of("lockRequest", request), SafeArg.of("requestingThread", request.getCreatingThreadName())); boolean indefinitelyBlocking = isIndefinitelyBlocking(request.getBlockingMode()); if (indefinitelyBlocking) { indefinitelyBlockingThreads.add(Thread.currentThread()); @Nullable Long deadline = (request.getBlockingDuration() == null) ? null : System.nanoTime() + request.getBlockingDuration().toNanos(); if (request.getBlockingMode() == BLOCK_UNTIL_TIMEOUT) { if (request.getLockGroupBehavior() == LOCK_AS_MANY_AS_POSSIBLE) { tryLocks(client, request, DO_NOT_BLOCK, null, LOCK_AS_MANY_AS_POSSIBLE, locks, failedLocks); tryLocks(client, request, request.getBlockingMode(), deadline, request.getLockGroupBehavior(), locks, failedLocks); if (request.getBlockingMode() == BlockingMode.BLOCK_INDEFINITELY_THEN_RELEASE) { if (log.isTraceEnabled()) { logNullResponse(client, request, null); requestLogger.debug("Timed out requesting {} for requesting thread {} after {} ms",
@Test public void setsGlobalDefaultLockTimeout() { TimeDuration expectedTimeout = SimpleTimeDuration.of(47, TimeUnit.SECONDS); AtlasDbConfig atlasDbConfig = ImmutableAtlasDbConfig.builder() .keyValueService(new InMemoryAtlasDbConfig()) .defaultLockTimeoutSeconds((int) expectedTimeout.getTime()) .build(); TransactionManagers.builder() .config(atlasDbConfig) .userAgent("test") .globalMetricsRegistry(new MetricRegistry()) .globalTaggedMetricRegistry(DefaultTaggedMetricRegistry.getDefault()) .registrar(environment) .build() .serializable(); assertEquals(expectedTimeout, LockRequest.getDefaultLockTimeout()); LockRequest lockRequest = LockRequest .builder(ImmutableSortedMap.of(StringLockDescriptor.of("foo"), LockMode.WRITE)).build(); assertEquals(expectedTimeout, lockRequest.getLockTimeout()); }
try { previousThreadName = updateThreadName(request); for (Entry<LockDescriptor, LockMode> entry : request.getLockDescriptors().entries()) { if (blockingMode == BlockingMode.BLOCK_INDEFINITELY_THEN_RELEASE && !descriptorToLockMap.asMap().containsKey(entry.getKey())) {
public static Supplier<AdvisoryLocksCondition> get(LockService lockService, Iterable<HeldLocksToken> lockTokens, Supplier<LockRequest> lockSupplier) { return () -> { Set<HeldLocksToken> externalLocks = ImmutableSet.copyOf(lockTokens); ExternalLocksCondition externalCondition = externalLocks.isEmpty() ? null : new ExternalLocksCondition(lockService, externalLocks); LockRequest lockRequest = lockSupplier.get(); if (lockRequest != null) { Validate.isTrue(lockRequest.getVersionId() == null, "Using a version id is not allowed"); HeldLocksToken newToken = acquireLock(lockService, lockRequest); TransactionLocksCondition transactionCondition = new TransactionLocksCondition(lockService, newToken); return externalCondition == null ? transactionCondition : new CombinedLocksCondition(externalCondition, transactionCondition); } return externalCondition == null ? NO_LOCKS_CONDITION : externalCondition; }; }
@Test public void lockRequestIsNonBlocking() throws InterruptedException { when(LOCK_CLIENT.lock(CLIENT, LOCK_NAME)).thenAnswer((invocation) -> { LockRequest request = (LockRequest) invocation.getArguments()[1]; assertThat(request.getBlockingMode(), is(BlockingMode.DO_NOT_BLOCK)); return null; }); LOCK_CLIENT.lock(CLIENT, LOCK_NAME); }
@Override public LockRefreshToken lock(String client, LockRequest request) throws InterruptedException { Preconditions.checkArgument(request.getLockGroupBehavior() == LockGroupBehavior.LOCK_ALL_OR_NONE, "lock() only supports LockGroupBehavior.LOCK_ALL_OR_NONE. Consider using lockAndGetHeldLocks()."); LockResponse result = lockWithFullLockResponse(LockClient.of(client), request); return result.success() ? result.getLockRefreshToken() : null; }
long lockTimeoutMs = LockRequest.getDefaultLockTimeout().toMillis(); LockRequest request = LockRequest.builder(ImmutableSortedMap.of( lock1, LockMode.READ, lock2, LockMode.WRITE)).withLockedInVersionId(10).build(); long currentTimeMs = System.currentTimeMillis(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); Assert.assertEquals(request.getLockDescriptors(), token1.getLockDescriptors()); Assert.assertTrue(currentTimeMs + lockTimeoutMs <= token1.getExpirationDateMs()); Assert.assertTrue(token1.getExpirationDateMs() HeldLocksToken validToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, LockRequest.builder( ImmutableSortedMap.of(lock2, LockMode.READ)).build()).getToken(); Assert.assertNotNull(validToken); HeldLocksToken anonymousReadToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, LockRequest.builder( ImmutableSortedMap.of(lock1, LockMode.READ)).build()).getToken(); Assert.assertNotNull(anonymousReadToken); server.unlock(anonymousReadToken); HeldLocksToken token2 = server.lockWithFullLockResponse(client, LockRequest.builder( ImmutableSortedMap.of(lock2, LockMode.READ)) .withLockedInVersionId(5).build()).getToken(); Assert.assertNotNull(token2); HeldLocksToken token3 = server.lockWithFullLockResponse(client, LockRequest.builder( ImmutableSortedMap.of(lock2, LockMode.WRITE)).build()).getToken(); Assert.assertNotNull(token3);
LockRequest request = LockRequest.builder( ImmutableSortedMap.of(lock1, LockMode.WRITE, lock2, LockMode.WRITE)).build(); HeldLocksToken token = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request).getToken(); Assert.assertNotNull(token); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); Assert.assertEquals(request.getLockDescriptors(), token.getLockDescriptors()); server.unlock(token);
static SanitizedLockRequestProgress create(LockServiceStateDebugger.LockRequestProgress progress, LockDescriptorMapper descriptorMapper, String clientId) { return ImmutableSanitizedLockRequestProgress.builder() .totalNumLocks(progress.getTotalNumLocks()) .numLocksAcquired(progress.getNumLocksAcquired()) .nextLock(progress.getNextLock().map(descriptorMapper::getDescriptorMapping) .orElse(UNKNOWN_NEXT_LOCK_MESSAGE)) .requests( StreamSupport.stream(progress.getRequest().getLockDescriptors().entries().spliterator(), false) .map(descriptor -> SimpleLockRequest.of( progress.getRequest(), descriptorMapper.getDescriptorMapping(descriptor.getKey()), descriptor.getValue(), clientId)) .collect(Collectors.toList())) .build(); } }
/** * Builds a {@link LockRequest} instance. After calling this method, the * builder object is invalidated. */ public LockRequest build() { if ((lockMap == null) || ((blockingMode == null) && (lockGroupBehavior != null))) { throw new IllegalStateException(); } if (versionId != null && blockingMode == BlockingMode.BLOCK_INDEFINITELY_THEN_RELEASE) { throw new IllegalStateException(); } String serverName = ""; if (!localServerName.isEmpty()) { serverName = " (on server " + localServerName + ")"; } LockRequest request = new LockRequest(lockMap, MoreObjects.firstNonNull(lockTimeout, getDefaultLockTimeout()), MoreObjects.firstNonNull(lockGroupBehavior, LockGroupBehavior.LOCK_ALL_OR_NONE), MoreObjects.firstNonNull(blockingMode, BlockingMode.BLOCK_INDEFINITELY), blockingDuration, versionId, MoreObjects.firstNonNull(creatingThreadName, Thread.currentThread().getName()) + serverName); lockMap = null; return request; }
public static Supplier<AdvisoryLocksCondition> get(LockService lockService, Iterable<HeldLocksToken> lockTokens, Supplier<LockRequest> lockSupplier) { return () -> { Set<HeldLocksToken> externalLocks = ImmutableSet.copyOf(lockTokens); ExternalLocksCondition externalCondition = externalLocks.isEmpty() ? null : new ExternalLocksCondition(lockService, externalLocks); LockRequest lockRequest = lockSupplier.get(); if (lockRequest != null) { Validate.isTrue(lockRequest.getVersionId() == null, "Using a version id is not allowed"); HeldLocksToken newToken = acquireLock(lockService, lockRequest); TransactionLocksCondition transactionCondition = new TransactionLocksCondition(lockService, newToken); return externalCondition == null ? transactionCondition : new CombinedLocksCondition(externalCondition, transactionCondition); } return externalCondition == null ? NO_LOCKS_CONDITION : externalCondition; }; }
LockRequest request = LockRequest.builder(mapToAssertLockHeld) .doNotBlock() .lockAsManyAsPossible() LockRequest request = LockRequest.builder(mapToAssertLockNotHeld).doNotBlock().build(); LockRefreshToken lock = lockService.lock(LockClient.ANONYMOUS.getClientId(), request); Validate.isTrue(lock != null, "these should already be waited for");
private LockRefreshToken lock(LockClient client, LockRequest request) throws InterruptedException { if (request.getBlockingMode() == BlockingMode.DO_NOT_BLOCK) { if (client == LockClient.ANONYMOUS) { return nonBlockingClient.lock(LockClient.ANONYMOUS.getClientId(), request); if ((request.getLockGroupBehavior() == LockGroupBehavior.LOCK_ALL_OR_NONE) && (request.getBlockingMode() != BlockingMode.BLOCK_INDEFINITELY_THEN_RELEASE)) { LockRequest.Builder newRequest = LockRequest.builder(request.getLockDescriptors()); newRequest.doNotBlock(); newRequest.timeoutAfter(request.getLockTimeout()); if (request.getVersionId() != null) { newRequest.withLockedInVersionId(request.getVersionId());