@Override public HeldLocksToken lockAndGetHeldLocks(String client, LockRequest request) throws InterruptedException { LockResponse result = lockWithFullLockResponse(LockClient.of(client), request); return result.getToken(); }
@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()); } }
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())); } }
/** 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()); }
/** 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()); }
HeldLocksToken token = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request).getToken(); Assert.assertNotNull(token); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); token = server.lockWithFullLockResponse(client, request).getToken(); HeldLocksToken token2 = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token2); Assert.assertEquals(client, token2.getClient()); Assert.assertEquals(LockCollections.of(ImmutableSortedMap.of(lock1, LockMode.WRITE)), token2.getLockDescriptors()); server.unlockAndFreeze(token2); token2 = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNull(token2); server.unlockAndFreeze(token); Assert.assertTrue(server.getTokens(client).isEmpty()); token = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token); token2 = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token2); HeldLocksToken token3 = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token3); server.unlockAndFreeze(token3); token3 = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNull(token3); Assert.assertTrue(server.getTokens(client).isEmpty()); HeldLocksToken token4 = server.lockWithFullLockResponse(client, LockRequest.builder(ImmutableSortedMap.of( lock2, LockMode.WRITE)).doNotBlock().build()).getToken(); Assert.assertNotNull(token4); Assert.assertEquals(ImmutableSet.of(token4), server.getTokens(client));
/** 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()); }
.doNotBlock().timeoutAfter(SimpleTimeDuration.of(500, TimeUnit.MILLISECONDS)) .build(); HeldLocksToken token = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token); Assert.assertEquals(client, token.getClient()); Thread.sleep(51); Assert.assertTrue(token.getExpirationDateMs() - System.currentTimeMillis() < 450); HeldLocksToken nullToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request).getToken(); Assert.assertNull(nullToken); Thread.sleep(450); token = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request).getToken(); Assert.assertNotNull(token); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); grant = server.refreshGrant(grant); Assert.assertTrue(grant.getExpirationDateMs() - System.currentTimeMillis() < 500); nullToken = server.lockWithFullLockResponse(LockClient.ANONYMOUS, request).getToken(); Assert.assertNull(nullToken); Thread.sleep(500); token = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertNotNull(token); Assert.assertEquals(client, token.getClient());
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);
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);
HeldLocksToken readWriteToken = server.lockWithFullLockResponse(client, requestAllLocks).getToken(); Assert.assertNotNull(readWriteToken); Assert.assertEquals(client, readWriteToken.getClient()); HeldLocksToken token = server.lockWithFullLockResponse(client, requestAllLocks).getToken(); Assert.assertNotNull(token); Assert.assertEquals(client, token.getClient()); token = server.lockWithFullLockResponse(client2, requestAllLocks).getToken(); Assert.assertNull(token); requestAllLocks = LockRequest.builder(lockMap).doNotBlock() .lockAsManyAsPossible().build(); token = server.lockWithFullLockResponse(client2, requestAllLocks).getToken(); Assert.assertNotNull(token); Assert.assertEquals(client2, token.getClient()); token = server.lockWithFullLockResponse(client2, requestAllLocks).getToken(); Assert.assertNotNull(token); Assert.assertEquals(client2, token.getClient());
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);
LockRequest requestTwoLocks = LockRequest.builder(ImmutableSortedMap.of( lock1, LockMode.READ, lock2, LockMode.WRITE)).doNotBlock().build(); HeldLocksToken token1 = server.lockWithFullLockResponse(client, requestWrite).getToken(); Assert.assertNotNull(token1); HeldLocksToken token2 = server.lockWithFullLockResponse(client, requestRead).getToken(); Assert.assertNotNull(token2); try { HeldLocksToken token3 = server.lockWithFullLockResponse(client, requestTwoLocks).getToken(); Assert.assertNotNull(token3); try { Assert.assertFalse(response.success()); Assert.assertEquals(ImmutableMap.of(lock1, client), response.getLockHolders()); HeldLocksToken nullToken = response.getToken(); Assert.assertNull(nullToken); 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());
HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); HeldLocksToken token2 = response.getToken(); System.out.println(response.getLockHolders()); Assert.assertNotNull(token2); response = server.lockWithFullLockResponse(client, request3); Assert.assertTrue(response.success()); HeldLocksToken token3 = response.getToken(); Assert.assertNotNull(token3); Assert.assertEquals(client, token3.getClient());
Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); HeldLocksToken token1 = response.getToken(); Assert.assertNotNull(token1); Assert.assertEquals(client, token1.getClient()); Assert.assertFalse(response1.getLockHolders().isEmpty()); Assert.assertEquals(ImmutableSortedMap.of(lock2, client), response1.getLockHolders()); HeldLocksToken nullToken = response1.getToken(); Assert.assertNull(nullToken); barrier.await(); 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(); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); HeldLocksToken anonymousReadToken = response.getToken(); Assert.assertNotNull(anonymousReadToken); server.unlock(anonymousReadToken); Assert.assertTrue(response.success());
.build(); token = server.lockWithFullLockResponse(client, request).getToken(); if (token == null) { numFailure.set(numFailure.get() + 1);
HeldLocksToken token = server.lockWithFullLockResponse(client, request).getToken(); Assert.assertEquals(client, token.getClient()); Assert.assertEquals(LockCollections.of(ImmutableSortedMap.of(lock, LockMode.READ)), token.getLockDescriptors()); HeldLocksToken token2 = server.lockWithFullLockResponse(client2, request2).getToken(); Assert.assertNull(token2); request2 = LockRequest.builder(ImmutableSortedMap.of(lock, LockMode.READ)) .blockForAtMost(server.getLockServerOptions().getMaxAllowedBlockingDuration()).build(); token2 = server.lockWithFullLockResponse(client2, request2).getToken(); Assert.assertNotNull(token2); server.unlock(token2);
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()); 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()); Assert.assertTrue(response.success()); Assert.assertTrue(response.getLockHolders().isEmpty()); token = response.getToken(); Assert.assertEquals(LockClient.ANONYMOUS, token.getClient()); Assert.assertEquals(LockCollections.of(ImmutableSortedMap.of(lock1, LockMode.READ, lock2, LockMode.READ)), token.getLockDescriptors()); Assert.assertFalse(response.getLockHolders().isEmpty()); Assert.assertEquals(ImmutableSortedMap.of(lock3, client, lock4, client), response.getLockHolders()); token = response.getToken(); Assert.assertNull(token);
ImmutableSortedMap.of(lock1, LockMode.READ)).doNotBlock().build()).getToken(); Assert.assertNotNull(token); Assert.assertEquals(ImmutableSet.of(token), server.getTokens(client));