Object readResolve() { if (isBlockAndRelease) { return new LockResponse(lockHolders); } return new LockResponse(token, lockHolders); } }
@Test public void testSerialisationAndDeserialisationOfLockResponseWithLockHolders() throws Exception { HeldLocksToken token = LockServiceTestUtils.getFakeHeldLocksToken("client A", "Fake thread", new BigInteger("1"), "held-lock-1", "logger-lock"); Map<LockDescriptor, LockClient> lockHolders = ImmutableMap.of(StringLockDescriptor.of("lock_id"), LockClient.ANONYMOUS, StringLockDescriptor.of("lock_id2"), LockClient.of("client")); LockResponse response = new LockResponse(token, lockHolders); ObjectMapper mapper = new ObjectMapper(); LockResponse deserializedLockResponse = mapper.readValue(mapper.writeValueAsString(response), LockResponse.class); assertEquals(lockHolders, deserializedLockResponse.getLockHolders()); }
@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(); }
@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; }
.doNotBlock().build(); LockResponse response = server.lockWithFullLockResponse(client, request); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); .blockForAtMost(SimpleTimeDuration.of(50, TimeUnit.MILLISECONDS)).build(); response = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request); Assert.assertTrue(response.success()); Assert.assertFalse(response.getLockHolders().isEmpty()); Assert.assertEquals(ImmutableMap.of(lock3, client), response.getLockHolders()); HeldLocksToken token = response.getToken(); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); Assert.assertEquals(LockCollections.of(ImmutableSortedMap.of(lock1, LockMode.READ)), token.getLockDescriptors()); .blockForAtMost(SimpleTimeDuration.of(50, TimeUnit.MILLISECONDS)).build(); response = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request); Assert.assertTrue(response.success()); Assert.assertFalse(response.getLockHolders().isEmpty()); Assert.assertEquals(ImmutableMap.of(lock4, client), response.getLockHolders()); token = response.getToken(); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); Assert.assertEquals(LockCollections.of(ImmutableSortedMap.of(lock2, LockMode.READ)), token.getLockDescriptors()); .blockForAtMost(SimpleTimeDuration.of(50, TimeUnit.MILLISECONDS)).build(); response = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); token = response.getToken(); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient());
/** Tests lockAndRelease */ @Test public void testLockAndRelease() throws Exception { LockRequest hasLock2 = LockRequest.builder(ImmutableSortedMap.of(lock2, LockMode.WRITE)).build(); final LockRequest request = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE, lock2, LockMode.WRITE)).lockAndRelease().build(); LockResponse resp2 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, hasLock2); Assert.assertTrue(resp2.success()); Future<?> future = executor.submit((Callable<Void>) () -> { LockResponse resp = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request); Assert.assertNotNull(resp); Assert.assertTrue(resp.success()); return null; }); try { future.get(1, TimeUnit.MILLISECONDS); Assert.fail(); } catch (TimeoutException e) { // good } server.unlock(resp2.getToken()); future.get(150, TimeUnit.SECONDS); resp2 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, hasLock2); server.unlock(resp2.getToken()); }
long currentTimeMs = System.currentTimeMillis(); LockResponse response1 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request1); Assert.assertTrue(response1.success()); Assert.assertTrue(response1.getLockHolders().isEmpty()); HeldLocksToken token1 = response1.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(LockClient.ANONYMOUS, token1.getClient()); LockRequest request2 = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE)).build(); LockResponse response2 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request2); HeldLocksToken validToken = response2.getToken(); Assert.assertNotNull(validToken); server.unlock(validToken);
/** Tests lockAndRelease with perf optimization */ @Test public void testLockAndRelease2() throws Exception { LockRequest hasLock1 = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE)).build(); LockRequest hasLock2 = LockRequest.builder(ImmutableSortedMap.of(lock2, LockMode.WRITE)).build(); final LockRequest request = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE, lock2, LockMode.WRITE)).lockAndRelease().build(); LockResponse resp2 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, hasLock2); Assert.assertTrue(resp2.success()); Future<?> future = executor.submit((Callable<Void>) () -> { LockResponse resp = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request); Assert.assertNotNull(resp); Assert.assertTrue(resp.success()); return null; }); Thread.sleep(10); try { future.get(1, TimeUnit.MILLISECONDS); Assert.fail(); } catch (TimeoutException e) { // good } LockResponse resp1 = server.lockWithFullLockResponse(client, hasLock1); server.unlock(resp2.getToken()); future.get(150, TimeUnit.SECONDS); server.unlock(resp1.getToken()); resp2 = server.lockWithFullLockResponse(LockClient.ANONYMOUS, hasLock2); server.unlock(resp2.getToken()); }
@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(); }
long currentTimeMs = System.currentTimeMillis(); LockResponse response = server.lockWithFullLockResponse(client, request); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); ImmutableSortedMap.of(lock2, LockMode.READ)) .blockForAtMost(SimpleTimeDuration.of(10, TimeUnit.MILLISECONDS)).build()); Assert.assertFalse(response1.success()); Assert.assertFalse(response1.getLockHolders().isEmpty()); Assert.assertEquals(ImmutableSortedMap.of(lock2, client), response1.getLockHolders()); HeldLocksToken nullToken = response1.getToken(); Assert.assertNull(nullToken); barrier.await(); ImmutableSortedMap.of(lock2, LockMode.READ)) .blockForAtMost(SimpleTimeDuration.of(100, TimeUnit.MILLISECONDS)).build()); Assert.assertTrue(response1.success()); Assert.assertTrue(response1.getLockHolders().isEmpty()); HeldLocksToken validToken = response1.getToken(); Assert.assertNotNull(validToken); server.unlock(validToken); server.unlock(token1); future.get(); token1 = server.lockWithFullLockResponse(client, request).getToken();
@Override public HeldLocksToken lockAndGetHeldLocks(String client, LockRequest request) throws InterruptedException { LockResponse result = lockWithFullLockResponse(LockClient.of(client), request); return result.getToken(); }
/** * Creates a new, successful {@code LockResponse} wrapping the given token, * with an empty lock holders map. */ public static LockResponse createSuccessful(HeldLocksToken token) { return new LockResponse(Preconditions.checkNotNull(token), ImmutableSortedMap.<LockDescriptor, LockClient>of()); }
long currentTimeMs = System.currentTimeMillis(); LockResponse response = server.lockWithFullLockResponse(client, request); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); barrier.await(); HeldLocksToken validToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, LockRequest.builder( ImmutableSortedMap.of(lock2, LockMode.READ)).build()).getToken(); Assert.assertNotNull(validToken); server.unlock(validToken); server.unlock(token1); future.get(); token1 = server.lockWithFullLockResponse(client, request).getToken(); ImmutableSortedMap.of(lock1, LockMode.READ)).build()).getToken(); Assert.assertNotNull(anonymousReadToken); server.unlock(anonymousReadToken); .withLockedInVersionId(5).build()).getToken(); Assert.assertNotNull(token2); ImmutableSortedMap.of(lock2, LockMode.WRITE)).build()).getToken(); Assert.assertNotNull(token3);
@Test public void testSimpleRefresh() throws InterruptedException { Builder builder = LockRequest.builder(ImmutableSortedMap.of(lock1, LockMode.WRITE)); builder.timeoutAfter(SimpleTimeDuration.of(5, TimeUnit.SECONDS)); LockResponse lock = server.lockWithFullLockResponse(LockClient.ANONYMOUS, builder.build()); Thread.sleep(10000); Set<HeldLocksToken> refreshTokens = server.refreshTokens(ImmutableList.of(lock.getToken())); Assert.assertEquals(1, refreshTokens.size()); } }
@Test public void testSerialisationAndDeserialisationOfLockResponse() throws Exception { HeldLocksToken token = LockServiceTestUtils.getFakeHeldLocksToken("client A", "Fake thread", new BigInteger("1"), "held-lock-1", "logger-lock"); LockResponse response = new LockResponse(token); ObjectMapper mapper = new ObjectMapper(); LockResponse deserializedLockResponse = mapper.readValue(mapper.writeValueAsString(response), LockResponse.class); assertEquals(deserializedLockResponse, response); }
long currentTimeMs = System.currentTimeMillis(); LockResponse response = server.lockWithFullLockResponse(client, request); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); ImmutableSortedMap.of(lock2, LockMode.READ)).doNotBlock().build()).getToken(); Assert.assertNull(nullToken); ImmutableSortedMap.of(lock2, LockMode.WRITE)).doNotBlock().build()).getToken(); Assert.assertNull(nullToken); .doNotBlock().build()).getToken(); Assert.assertNotNull(anonymousReadToken); server.unlock(anonymousReadToken); .withLockedInVersionId(5).doNotBlock().build()).getToken(); Assert.assertNotNull(token2); ImmutableSortedMap.of(lock2, LockMode.WRITE)).doNotBlock().build()).getToken(); Assert.assertNotNull(token3);
private void testReentrancy(LockMode mode1, LockMode mode2) throws InterruptedException { LockResponse lockResponse1 = server.lockWithFullLockResponse( client, LockRequest.builder(ImmutableSortedMap.of(lock1, mode1)).build()); LockResponse lockResponse2 = server.lockWithFullLockResponse( client, LockRequest.builder(ImmutableSortedMap.of(lock1, mode2)).build()); server.unlockSimple(SimpleHeldLocksToken.fromHeldLocksToken(lockResponse1.getToken())); server.unlockSimple(SimpleHeldLocksToken.fromHeldLocksToken(lockResponse2.getToken())); } }
SafeArg.of("timeoutMillis", System.currentTimeMillis() - startTime)); return new LockResponse(failedLocks); logLockAcquisitionFailure(failedLocks); return new LockResponse(null, failedLocks); SafeArg.of("waitMillis", System.currentTimeMillis() - startTime)); return new LockResponse(token, failedLocks); } finally { outstandingLockRequestMultimap.remove(client, request);
HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); HeldLocksToken token2 = response.getToken(); System.out.println(response.getLockHolders()); Assert.assertNotNull(token2); Assert.assertEquals(LockClient.ANONYMOUS, token2.getClient()); .blockForAtMost(SimpleTimeDuration.of(100, TimeUnit.MILLISECONDS)).build(); response = server.lockWithFullLockResponse(client, request3); Assert.assertTrue(response.success()); HeldLocksToken token3 = response.getToken(); Assert.assertNotNull(token3); Assert.assertEquals(client, token3.getClient());