private LockRefreshToken lockAnonymous(com.palantir.lock.LockRequest request) { try { return lockService.lock(LockClient.ANONYMOUS.getClientId(), request); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); throw new RuntimeException(ex); } }
/** Tests that RemoteLockService api (that internal forwards to LockService api) passes a sanity check. */ @Test public void testRemoteLockServiceApi() throws InterruptedException { LockRequest request = LockRequest.builder(ImmutableSortedMap.of( lock1, LockMode.READ, lock2, LockMode.WRITE)) .withLockedInVersionId(10).doNotBlock().build(); Assert.assertNull(server.getMinLockedInVersionId(LockClient.ANONYMOUS.getClientId())); LockRefreshToken token = server.lock(LockClient.ANONYMOUS.getClientId(), request); Assert.assertEquals(10, (long) server.getMinLockedInVersionId(LockClient.ANONYMOUS.getClientId())); Assert.assertNull(server.lock(LockClient.ANONYMOUS.getClientId(), request)); server.unlock(token); Assert.assertNull(server.getMinLockedInVersionId(LockClient.ANONYMOUS.getClientId())); HeldLocksToken heldToken = server.lockAndGetHeldLocks(LockClient.ANONYMOUS.getClientId(), request); Assert.assertEquals(10, (long) server.getMinLockedInVersionId(LockClient.ANONYMOUS.getClientId())); Assert.assertNull(server.lockAndGetHeldLocks(LockClient.ANONYMOUS.getClientId(), request)); server.unlock(heldToken.getLockRefreshToken()); }
@Nullable @Override public LockRefreshToken lock(String client, LockRequest request) throws InterruptedException { return wrapper.applyWithPermit(lockService -> lockService.lock(client, request)); }
private void givenTableIsLocked(String table) throws InterruptedException { when(lockService.lock(any(), requestContaining(table))).thenReturn(null); }
@Test public void lockOrRefreshCallsLockWhenNoTokenPresent() throws InterruptedException { lockService.lockOrRefresh(); verify(mockLockService, atLeastOnce()).lock(any(), any()); verifyNoMoreInteractions(mockLockService); }
@Before public void setup() throws InterruptedException { lockService = mock(LockService.class); LockRefreshToken token = new LockRefreshToken(BigInteger.ONE, Long.MAX_VALUE); when(lockService.lock(anyString(), any())).thenReturn(token); calculator = mock(StreamStoreRemappingSweepPriorityCalculator.class); priorities = new HashMap<>(); priorityTables = new HashSet<>(); blacklistTables = new HashSet<>(); provider = new NextTableToSweepProvider(lockService, calculator); }
@Test public void lockOrRefreshCallsRefreshWhenTokenPresent() throws InterruptedException { LockRefreshToken token = new LockRefreshToken(BigInteger.ONE, 10000000000L); when(mockLockService.lock(anyString(), any())).thenReturn(token); lockService.lockOrRefresh(); verify(mockLockService, atLeastOnce()).lock(any(), any()); lockService.lockOrRefresh(); verify(mockLockService, atLeastOnce()).refreshLockRefreshTokens(ImmutableList.of(token)); verifyNoMoreInteractions(mockLockService); }
.lockAsManyAsPossible() .build(); LockRefreshToken lock = lockService.lock(LockClient.ANONYMOUS.getClientId(), request); Validate.isTrue(lock == null, "these should already be held"); LockRefreshToken lock = lockService.lock(LockClient.ANONYMOUS.getClientId(), request); Validate.isTrue(lock != null, "these should already be waited for");
@Test public void closeUnlocksToken() throws InterruptedException { LockRefreshToken token = new LockRefreshToken(BigInteger.ONE, 10000000000L); when(mockLockService.lock(anyString(), any())).thenReturn(token); lockService.lockOrRefresh(); lockService.close(); verify(mockLockService, atLeastOnce()).unlock(token); } }
@Override public LockRefreshToken lock(String client, String lockName) throws InterruptedException { LockDescriptor descriptor = StringLockDescriptor.of(lockName); LockRequest request = LockRequest.builder(ImmutableSortedMap.of(descriptor, LockMode.WRITE)) .doNotBlock() .build(); return lockService.lock(client, request); }
@Test public void lockClearedWhenRefreshReturnsEmpty() throws InterruptedException { when(mockLockService.lock(anyString(), any())).thenReturn(new LockRefreshToken(BigInteger.ONE, 10000000000L)); lockService.lockOrRefresh(); when(mockLockService.refreshLockRefreshTokens(any())).thenReturn(ImmutableSet.of()); lockService.lockOrRefresh(); assertFalse(lockService.haveLocks()); }
@Test public void lockStoredInToken() throws InterruptedException { when(mockLockService.lock(anyString(), any())).thenReturn(new LockRefreshToken(BigInteger.ONE, 10000000000L)); lockService.lockOrRefresh(); assertTrue(lockService.haveLocks()); }
@Test public void waitForLocksDelegatesToLockService() throws InterruptedException { com.palantir.lock.LockRequest legacyRequest = com.palantir.lock.LockRequest.builder(buildLockMap(LockMode.READ)).lockAndRelease().build(); when(lockService.lock(LockClient.ANONYMOUS.getClientId(), legacyRequest)).thenReturn(LOCK_REFRESH_TOKEN); timelock.waitForLocks(WaitForLocksRequest.of(ImmutableSet.of(LOCK_A, LOCK_B), TIMEOUT)); verify(lockService).lock(LockClient.ANONYMOUS.getClientId(), legacyRequest); }
@Test public void lockDelegatesToLockService() throws InterruptedException { com.palantir.lock.LockRequest legacyRequest = com.palantir.lock.LockRequest.builder(buildLockMap(LockMode.WRITE)) .blockForAtMost(SimpleTimeDuration.of(TIMEOUT, TimeUnit.MILLISECONDS)) .build(); when(lockService.lock(LockClient.ANONYMOUS.getClientId(), legacyRequest)).thenReturn(LOCK_REFRESH_TOKEN); assertEquals(LockResponse.successful(LOCK_TOKEN_V2), timelock.lock( LockRequest.of(ImmutableSet.of(LOCK_A, LOCK_B), TIMEOUT))); verify(lockService).lock(LockClient.ANONYMOUS.getClientId(), legacyRequest); }
private LockRefreshToken mockImmutableTsLockResponse() throws InterruptedException { LockDescriptor descriptor = AtlasTimestampLockDescriptor.of(FRESH_TIMESTAMP); com.palantir.lock.LockRequest expectedRequest = com.palantir.lock.LockRequest.builder(ImmutableSortedMap.of(descriptor, LockMode.READ)) .withLockedInVersionId(FRESH_TIMESTAMP).build(); LockRefreshToken expectedToken = new LockRefreshToken(BigInteger.ONE, 123L); when(lockService.lock(LOCK_CLIENT.getClientId(), expectedRequest)).thenReturn(expectedToken); return expectedToken; }
@Override public LockImmutableTimestampResponse lockImmutableTimestamp(IdentifiedTimeLockRequest request) { long immutableLockTs = timestampService.getFreshTimestamp(); LockDescriptor lockDesc = AtlasTimestampLockDescriptor.of(immutableLockTs); com.palantir.lock.LockRequest lockRequest = com.palantir.lock.LockRequest.builder( ImmutableSortedMap.of(lockDesc, LockMode.READ)) .withLockedInVersionId(immutableLockTs).build(); LockRefreshToken lock; try { lock = lockService.lock(immutableTsLockClient.getClientId(), lockRequest); } catch (InterruptedException e) { throw Throwables.throwUncheckedException(e); } try { return LockImmutableTimestampResponse.of( getImmutableTimestampInternal(immutableLockTs), LockTokenConverter.toTokenV2(lock)); } catch (Throwable e) { if (lock != null) { lockService.unlock(lock); } throw Throwables.rewrapAndThrowUncheckedException(e); } }
private void runAndVerifyCli(Verifier verifier) throws Exception { try (SingleBackendCliTestRunner runner = makeRunner(cliArgs.toArray(new String[0]))) { TestAtlasDbServices services = runner.connect(moduleFactory); LockService lockService = services.getLockService(); TimestampService tss = services.getTimestampService(); LockClient client = services.getTestLockClient(); Clock clock = GlobalClock.create(lockService); long prePunch = clock.getTimeMillis(); punch(services, tss, clock); long postPunch = clock.getTimeMillis(); long immutableTs = tss.getFreshTimestamp(); LockRequest request = LockRequest.builder(ImmutableSortedMap.of(lock, LockMode.WRITE)) .withLockedInVersionId(immutableTs) .doNotBlock() .build(); LockRefreshToken token = lockService.lock(client.getClientId(), request); long lastFreshTs = tss.getFreshTimestamps(1000).getUpperBound(); verifier.verify(runner, tss, immutableTs, prePunch, postPunch, lastFreshTs, true); lockService.unlock(token); lastFreshTs = tss.getFreshTimestamps(1000).getUpperBound(); // there are no locks so we now expect immutable to just be a fresh runner.freshCommand(); verifier.verify(runner, tss, immutableTs, prePunch, postPunch, lastFreshTs, false); } }
.lockAsManyAsPossible() .build(); LockRefreshToken lock = lockService.lock(LockClient.ANONYMOUS.getClientId(), request); Validate.isTrue(lock == null, "these should already be held"); LockRefreshToken lock = lockService.lock(LockClient.ANONYMOUS.getClientId(), request); Validate.isTrue(lock != null, "these should already be waited for");