@Provides @Singleton public LockClient provideLockClient() { return LockClient.of("atlas instance"); }
Object readResolve() { if (Strings.isNullOrEmpty(clientId)) { return ANONYMOUS; } if (clientId.equals(INTERNAL_LOCK_GRANT_CLIENT_ID)) { return INTERNAL_LOCK_GRANT_CLIENT; } return of(clientId); } }
@Provides @Singleton public LockClient provideLockClient() { return LockClient.of("atlas instance"); }
@Override public LockRefreshToken lock(String client, LockRequest request) throws InterruptedException { LockRefreshToken result = lock(LockClient.of(client), request); return result; }
@Override public Long getMinLockedInVersionId(String client) { return getMinLockedInVersionId(LockClient.of(client)); }
@Override public HeldLocksToken lockAndGetHeldLocks(String client, LockRequest request) throws InterruptedException { LockResponse result = lockWithFullLockResponse(LockClient.of(client), request); return result.getToken(); }
public static HeldLocksToken getFakeHeldLocksToken(String clientName, String requestingThread, BigInteger tokenId, String... descriptors) { ImmutableSortedMap<LockDescriptor, LockMode> lockDescriptorLockMode = getLockDescriptorLockMode(Arrays.asList(descriptors)); return new HeldLocksToken(tokenId, LockClient.of(clientName), System.currentTimeMillis(), System.currentTimeMillis(), LockCollections.of(lockDescriptorLockMode), LockRequest.getDefaultLockTimeout(), 0L, requestingThread); }
@BeforeClass public static void setupLockClient() { if (lockClient == null) { lockClient = LockClient.of("fake lock client"); } }
@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; }
private static HeldLocksToken getHeldLocksToken(BigInteger tokenId) { long creationDateMs = System.currentTimeMillis(); long expirationDateMs = creationDateMs - 1; TimeDuration lockTimeout = SimpleTimeDuration.of(0, TimeUnit.SECONDS); long versionId = 0L; return new HeldLocksToken( tokenId, LockClient.of("fake lock client"), creationDateMs, expirationDateMs, LOCK_DESCRIPTORS, lockTimeout, versionId, "Dummy thread"); } }
@Before public void setUp() { new File("lock_server_timestamp.dat").delete(); server = getLockService(); client = LockClient.of("a client"); lock1 = StringLockDescriptor.of("lock1"); lock2 = StringLockDescriptor.of("lock2"); barrier = new CyclicBarrier(2); }
@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()); }
@Test public void shouldNotMakeRemoteCallsInAReadonlyTransactionIfNoWorkIsDone() { TimestampService mockTimestampService = mock(TimestampService.class); TimestampManagementService mockTimestampManagementService = mock(TimestampManagementService.class); LockService mockLockService = mock(LockService.class); TransactionManager txnManagerWithMocks = SerializableTransactionManager.createForTest( metricsManager, getKeyValueService(), mockTimestampService, mockTimestampManagementService, LockClient.of("foo"), mockLockService, transactionService, () -> AtlasDbConstraintCheckingMode.FULL_CONSTRAINT_CHECKING_THROWS_EXCEPTIONS, conflictDetectionManager, sweepStrategyManager, NoOpCleaner.INSTANCE, AbstractTransactionTest.GET_RANGES_THREAD_POOL_SIZE, AbstractTransactionTest.DEFAULT_GET_RANGES_CONCURRENCY, MultiTableSweepQueueWriter.NO_OP); // fetch an immutable timestamp once so it's cached when(mockTimestampService.getFreshTimestamp()).thenReturn(1L); when(mockLockService.getMinLockedInVersionId("foo")).thenReturn(1L); txnManagerWithMocks.getImmutableTimestamp(); verify(mockTimestampService).getFreshTimestamp(); verify(mockLockService).getMinLockedInVersionId("foo"); // now execute a read transaction txnManagerWithMocks.runTaskReadOnly(txn -> null); verifyNoMoreInteractions(mockLockService); verifyNoMoreInteractions(mockTimestampService); verifyNoMoreInteractions(mockTimestampManagementService); }
@Test public void testSerializationDeserialization() throws Exception { SortedMap<LockDescriptor, LockMode> lockMap = ImmutableSortedMap.of(StringLockDescriptor.of("foo"), LockMode.READ); HeldLocksToken heldLocksToken = new HeldLocksToken( BigInteger.valueOf(0), LockClient.of("foo"), 0, 0, LockCollections.of(lockMap), SimpleTimeDuration.of(1, TimeUnit.SECONDS), 0L, "Dummy Thread"); HeldLocksToken deserializedHeldLocksToken = mapper.readValue(mapper.writeValueAsString(heldLocksToken), HeldLocksToken.class); assertThat(deserializedHeldLocksToken, is(heldLocksToken)); }
@Test public void testPathParamSerDeOfLockClient() throws Exception { LockClient lockClient = LockClient.of("xyz"); String serializedForm = lockClient.toString(); LockClient lockClient1 = new LockClient(serializedForm); assertEquals(lockClient, lockClient1); }
timestampService, (TimestampManagementService) timestampService, LockClient.of("test"), LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build()), transactionService,
LockService lock = LockRefreshingLockService.create(LockServiceImpl.create( LockServerOptions.builder().isStandaloneServer(false).build())); LockClient client = LockClient.of("in memory atlasdb instance"); ConflictDetectionManager conflictManager = ConflictDetectionManagers.createWithoutWarmingCache(keyValueService); SweepStrategyManager sweepStrategyManager = SweepStrategyManagers.createDefault(keyValueService);
public static TransactionManager setupTxManager(KeyValueService kvs, TimestampService tsService, TimestampManagementService tsmService, SweepStrategyManager ssm, TransactionService txService) { MetricsManager metricsManager = MetricsManagers.createForTests(); LockClient lockClient = LockClient.of("sweep client"); LockService lockService = LockServiceImpl.create( LockServerOptions.builder().isStandaloneServer(false).build()); Supplier<AtlasDbConstraintCheckingMode> constraints = () -> AtlasDbConstraintCheckingMode.NO_CONSTRAINT_CHECKING; ConflictDetectionManager cdm = ConflictDetectionManagers.createWithoutWarmingCache(kvs); Cleaner cleaner = new NoOpCleaner(); MultiTableSweepQueueWriter writer = TargetedSweeper.createUninitializedForTest(() -> 1); TransactionManager txManager = SerializableTransactionManager.createForTest( metricsManager, kvs, tsService, tsmService, lockClient, lockService, txService, constraints, cdm, ssm, cleaner, AbstractTransactionTest.GET_RANGES_THREAD_POOL_SIZE, AbstractTransactionTest.DEFAULT_GET_RANGES_CONCURRENCY, writer); setupTables(kvs); writer.initialize(txManager); return txManager; }
@Test public void canCloseTransactionManagerWithNonCloseableLockService() { InMemoryTimestampService ts = new InMemoryTimestampService(); SnapshotTransactionManager newTransactionManager = new SnapshotTransactionManager( metricsManager, keyValueService, new LegacyTimelockService(ts, closeableLockService, LockClient.of("lock")), ts, mock(LockService.class), // not closeable null, null, null, null, cleaner, false, TransactionTestConstants.GET_RANGES_THREAD_POOL_SIZE, TransactionTestConstants.DEFAULT_GET_RANGES_CONCURRENCY, TimestampCache.createForTests(), MultiTableSweepQueueWriter.NO_OP, executorService, true, () -> ImmutableTransactionConfig.builder().build()); newTransactionManager.close(); // should not throw }
@Before public void setup() { kvs = new InMemoryKeyValueService(true); InMemoryTimestampService tsService = new InMemoryTimestampService(); LockClient lockClient = LockClient.of("sweep client"); lockService = LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build()); txService = TransactionServices.createForTesting(kvs, tsService, false); Supplier<AtlasDbConstraintCheckingMode> constraints = Suppliers.ofInstance( AtlasDbConstraintCheckingMode.NO_CONSTRAINT_CHECKING); ConflictDetectionManager cdm = ConflictDetectionManagers.createWithoutWarmingCache(kvs); SweepStrategyManager ssm = SweepStrategyManagers.createDefault(kvs); Cleaner cleaner = new NoOpCleaner(); metricsManager = MetricsManagers.createForTests(); TransactionManager transactionManager = SerializableTransactionManager.createForTest( metricsManager, kvs, tsService, tsService, lockClient, lockService, txService, constraints, cdm, ssm, cleaner, AbstractTransactionTest.GET_RANGES_THREAD_POOL_SIZE, AbstractTransactionTest.DEFAULT_GET_RANGES_CONCURRENCY, MultiTableSweepQueueWriter.NO_OP); txManager = transactionManager; }