Object readResolve() { return new HeldLocksToken(tokenId, client, creationDateMs, expirationDateMs, lockMap, lockTimeout, versionId, requestingThread); } }
@Override @Nullable public LockRefreshToken apply(@Nullable HeldLocksToken input) { return input.getLockRefreshToken(); } };
public static SimpleTokenInfo of(HeldLocksToken token, LockMode lockMode) { return ImmutableSimpleTokenInfo.builder() .lockMode(lockMode) .expiresIn(token.getExpirationDateMs() - System.currentTimeMillis()) .createdAtTs(token.getCreationDateMs()) .tokenId(token.getTokenId().toString()) .clientId(Preconditions.checkNotNull(token.getClient()).getClientId()) .requestThread(token.getRequestingThread()) .createAt(new Date(token.getCreationDateMs()).toString()) .versionId(token.getVersionId()) .build(); }
public HeldLocksToken refreshTokenWithExpriationDate(HeldLocksToken token) { Preconditions.checkArgument(token.getTokenId().equals(tokenId), "token ids must match"); return token.refresh(expirationDateMs); }
public static SimpleHeldLocksToken fromHeldLocksToken(HeldLocksToken token) { return new SimpleHeldLocksToken(token.getTokenId(), token.getCreationDateMs()); }
HeldLocksToken token1 = response1.getToken(); 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() <= System.currentTimeMillis() + lockTimeoutMs);
log.warn("Cannot convert to grant; invalid token: {} (token ID {})", UnsafeArg.of("token", token), SafeArg.of("tokenId", token.getTokenId())); throw new IllegalArgumentException("token is invalid: " + token); log.warn("Cannot convert to grant because token is frozen: {} (token ID {})", UnsafeArg.of("token", token), SafeArg.of("tokenId", token.getTokenId())); throw new IllegalArgumentException("token is frozen: " + token); changeOwner(heldLocks.locks, heldLocks.realToken.getClient(), INTERNAL_LOCK_GRANT_CLIENT); } catch (IllegalMonitorStateException e) { log.warn("Failure converting {} (token ID {}) to grant", UnsafeArg.of("token", token), SafeArg.of("tokenId", token.getTokenId()), e); throw e; lockClientMultimap.remove(heldLocks.realToken.getClient(), token); HeldLocksGrant grant = createHeldLocksGrant(heldLocks.realToken.getLockDescriptors(), heldLocks.locks, heldLocks.realToken.getLockTimeout(), heldLocks.realToken.getVersionId()); if (log.isTraceEnabled()) { log.trace(".convertToGrant({}) (token ID {}) returns {} (grant ID {})", UnsafeArg.of("token", token), SafeArg.of("tokenId", token.getTokenId()), UnsafeArg.of("grant", grant),
/** 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()); }
HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); Assert.assertEquals(10, (long) token1.getVersionId()); Assert.assertEquals(request.getLockDescriptors(), token1.getLockDescriptors()); Assert.assertTrue(currentTimeMs + lockTimeoutMs <= token1.getExpirationDateMs()); Assert.assertTrue(token1.getExpirationDateMs() <= System.currentTimeMillis() + lockTimeoutMs);
@Override public String toString() { return toString(System.currentTimeMillis()); }
@Nullable private HeldLocksToken refreshToken(HeldLocksToken token) { Preconditions.checkNotNull(token); @Nullable HeldLocks<HeldLocksToken> heldLocks = heldLocksTokenMap.get(token); if ((heldLocks == null) || isFrozen(heldLocks.locks.getKeys())) { return null; } long now = currentTimeMillis(); long expirationDateMs = now + heldLocks.realToken.getLockTimeout().toMillis(); heldLocksTokenMap.replace(token, heldLocks, new HeldLocks<HeldLocksToken>( heldLocks.realToken.refresh(expirationDateMs), heldLocks.locks)); heldLocks = heldLocksTokenMap.get(token); if (heldLocks == null) { return null; } HeldLocksToken finalToken = heldLocks.realToken; logIfAbnormallyOld(finalToken, now); return finalToken; }
LockClient client = heldLocks.realToken.getClient(); if (client.isAnonymous()) { heldLocksTokenMap.put(token, heldLocks); if (heldLocks.realToken.getVersionId() != null) { versionIdMap.remove(client, heldLocks.realToken.getVersionId());
@Override public HeldLocksToken useGrant(LockClient client, HeldLocksGrant grant) { Preconditions.checkNotNull(client); Preconditions.checkArgument(client != INTERNAL_LOCK_GRANT_CLIENT); Preconditions.checkNotNull(grant); @Nullable HeldLocks<HeldLocksGrant> heldLocks = heldLocksGrantMap.remove(grant); if (heldLocks == null) { log.warn("Tried to use invalid grant: {} (grant ID {})", UnsafeArg.of("grant", grant), SafeArg.of("grantId", grant.getGrantId())); throw new IllegalArgumentException("grant is invalid: " + grant); } HeldLocksGrant realGrant = heldLocks.realToken; changeOwner(heldLocks.locks, INTERNAL_LOCK_GRANT_CLIENT, client); HeldLocksToken token = createHeldLocksToken(client, realGrant.getLockDescriptors(), heldLocks.locks, realGrant.getLockTimeout(), realGrant.getVersionId(), "Converted from Grant, Missing Thread Name"); if (log.isTraceEnabled()) { log.trace(".useGrant({}, {}) (grant ID {}) returns {} (token ID {})", SafeArg.of("client", client), UnsafeArg.of("grant", grant), SafeArg.of("grantId", grant.getGrantId()), UnsafeArg.of("token", token), SafeArg.of("tokenId", token.getTokenId())); } return token; }
@Test public void noRetryOnExpiredLockTokens() throws InterruptedException { HeldLocksToken expiredLockToken = getExpiredHeldLocksToken(); try { txManager.runTaskWithLocksWithRetry(ImmutableList.of(expiredLockToken), () -> null, (tx, locks) -> { tx.put(TABLE, ImmutableMap.of(TEST_CELL, PtBytes.toBytes("value"))); return null; }); fail(); } catch (TransactionLockTimeoutNonRetriableException e) { LockDescriptor descriptor = Iterables.getFirst(expiredLockToken.getLockDescriptors(), null); assertThat(e.getMessage(), containsString(descriptor.toString())); assertThat(e.getMessage(), containsString("Retry is not possible.")); } }
@Override public boolean equals(@Nullable Object obj) { if (this == obj) { return true; } if (!(obj instanceof LockResponse)) { return false; } return token.equals(((LockResponse) obj).token) && lockHolders.equals(((LockResponse) obj).getLockHolders()) && isBlockAndRelease == ((LockResponse) obj).isBlockAndRelease(); }
Assert.assertEquals(client2, validToken.getClient()); server.unlock(validToken); token1 = server.lockWithFullLockResponse(client, requestWrite).getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); Future<?> future = executor.submit((Callable<Void>) () -> { HeldLocksToken validToken1 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, LockRequest.builder( ImmutableSortedMap.of(lock1, LockMode.WRITE)).build()).getToken(); Assert.assertNotNull(validToken1); Assert.assertEquals(LockClient.ANONYMOUS, validToken1.getClient()); server.unlock(validToken1); Assert.assertEquals(client2, validToken.getClient());
HeldLocksToken token = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token); Assert.assertEquals(client, token.getClient()); Assert.assertEquals(request.getLockDescriptors(), token.getLockDescriptors()); Thread.sleep(51); Assert.assertTrue(token.getExpirationDateMs() - System.currentTimeMillis() < 450); HeldLocksToken nullToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request).getToken(); Assert.assertNull(nullToken); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); Assert.assertEquals(request.getLockDescriptors(), token.getLockDescriptors()); Assert.assertEquals(client, token.getClient()); Assert.assertEquals(request.getLockDescriptors(), token.getLockDescriptors()); server.unlock(token); Assert.assertTrue(server.getTokens(client).isEmpty());
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);
public HeldLocksToken refreshTokenWithExpriationDate(HeldLocksToken token) { Preconditions.checkArgument(token.getTokenId().equals(tokenId), "token ids must match"); return token.refresh(expirationDateMs); }
public static SimpleHeldLocksToken fromHeldLocksToken(HeldLocksToken token) { return new SimpleHeldLocksToken(token.getTokenId(), token.getCreationDateMs()); }