public static TransactionManager mockTxManager() { TransactionManager txManager = mock(TransactionManager.class); Answer runTaskAnswer = inv -> { Object[] args = inv.getArguments(); TransactionTask<?, ?> task = (TransactionTask<?, ?>) args[0]; return task.execute(mock(Transaction.class)); }; doAnswer(runTaskAnswer).when(txManager).runTaskReadOnly(any()); doAnswer(runTaskAnswer).when(txManager).runTaskWithRetry(any()); return txManager; }
@Test public void shouldNotRunTaskWithRetryWithClosedTransactionManager() { txMgr.close(); assertThatThrownBy(() -> txMgr.runTaskWithRetry((TransactionTask<Void, RuntimeException>) txn -> { put(txn, "row1", "col1", "v1"); return null; })) .isInstanceOf(IllegalStateException.class) .hasMessage("Operations cannot be performed on closed TransactionManager."); }
protected final void storeMetadataAndIndex(final long streamId, final StreamMetadata metadata) { Preconditions.checkNotNull(txnMgr, "Transaction manager must not be null"); txnMgr.runTaskThrowOnConflict((TxTask) tx -> { putMetadataAndHashIndexTask(tx, streamId, metadata); return null; }); }
public void initializeWithoutRunning(TransactionManager txManager) { initializeWithoutRunning(SpecialTimestampsSupplier.create(txManager), txManager.getTimelockService(), txManager.getKeyValueService(), TransactionServices.createTransactionService(txManager.getKeyValueService(), CoordinationServices.createDefault( txManager.getKeyValueService(), txManager.getTimestampService(), false)), new TargetedSweepFollower(followers, txManager)); }
private boolean isInitializedInternal() { // Note that the PersistentLockService is also initialized asynchronously as part of // TransactionManagers.create; however, this is not required for the TransactionManager to fulfil // requests (note that it is not accessible from any TransactionManager implementation), so we omit // checking here whether it is initialized. return txManager.getKeyValueService().isInitialized() && txManager.getTimelockService().isInitialized() && txManager.getTimestampService().isInitialized() && txManager.getCleaner().isInitialized() && initializationPrerequisite.get(); }
@Override public boolean doTransactionAndReportOutcome() { try { return transactionManager.runTaskThrowOnConflict(tx -> { KeyValueService kvs = transactionManager.getKeyValueService(); kvs.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); tx.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, new byte[1])); return true; }); } catch (Exception e) { return false; } }
private void validateTable(final TableReference table, final int limit, final Transaction t1) { // read only, but need to use a write tx in case the source table has SweepStrategy.THOROUGH validationToTransactionManager.runTaskWithRetry( (TransactionTask<Map<Cell, byte[]>, RuntimeException>) t2 -> { validateTable(table, limit, t1, t2); return null; }); }
Optional<String> selectTableToCompact() { return transactionManager.runTaskReadOnly(this::selectTableToCompactInternal); }
@Override public void init(TransactionManager resource) { try { resource.getKeyValueService().dropTables(deprecatedTables); log.info("Successfully dropped deprecated tables on startup."); } catch (Throwable e) { log.info("Could not drop deprecated tables from the underlying KeyValueService.", e); } }
@After public void closeTransactionManager() { txManager.close(); }
@Test public void shouldNotRunTaskReadOnlyWithClosedTransactionManager() { txMgr.close(); assertThatThrownBy(() -> txMgr.runTaskReadOnly((TransactionTask<Void, RuntimeException>) txn -> { put(txn, "row1", "col1", "v1"); return null; })) .isInstanceOf(IllegalStateException.class) .hasMessage("Operations cannot be performed on closed TransactionManager."); }
public static CoordinationResource create(TransactionManager transactionManager) { return new SimpleCoordinationResource(transactionManager, new TransactionSchemaManager( CoordinationServices.createDefault( transactionManager.getKeyValueService(), transactionManager.getTimestampService(), false))); }
@Test public void shouldNotRunTaskThrowOnConflictWithClosedTransactionManager() { txMgr.close(); assertThatThrownBy(() -> txMgr.runTaskThrowOnConflict((TransactionTask<Void, RuntimeException>) txn -> { put(txn, "row1", "col1", "v1"); return null; })) .isInstanceOf(IllegalStateException.class) .hasMessage("Operations cannot be performed on closed TransactionManager."); }
@Override public void registerClosingCallback(Runnable closingCallback) { assertOpen(); txManager.registerClosingCallback(closingCallback); }
@Test public void runsClosingCallbackOnShutdown() throws Exception { AtlasDbConfig atlasDbConfig = ImmutableAtlasDbConfig.builder() .keyValueService(new InMemoryAtlasDbConfig()) .defaultLockTimeoutSeconds(120) .build(); Runnable callback = mock(Runnable.class); TransactionManager manager = TransactionManagers.builder() .config(atlasDbConfig) .userAgent("test") .globalMetricsRegistry(new MetricRegistry()) .globalTaggedMetricRegistry(DefaultTaggedMetricRegistry.getDefault()) .registrar(environment) .build() .serializable(); manager.registerClosingCallback(callback); manager.close(); verify(callback, times(1)).run(); }
private SimpleCoordinationResource( TransactionManager transactionManager, TransactionSchemaManager transactionSchemaManager) { this.transactionManager = transactionManager; this.transactionSchemaManager = transactionSchemaManager; this.timestampService = transactionManager.getTimestampService(); }
@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); }
@Override public LockService getLockService() { assertOpen(); return txManager.getLockService(); }
@Override public final void performOneCall() { txnManager.runTaskWithRetry(txn -> { writeValues(txn, allValues); return null; }); }
private TargetedSweeper initializeAndGet(TargetedSweeper sweeper, TransactionManager txManager) { sweeper.initializeWithoutRunning( new SpecialTimestampsSupplier(txManager::getImmutableTimestamp, txManager::getImmutableTimestamp), txManager.getTimelockService(), txManager.getKeyValueService(), TransactionServices.createForTesting( txManager.getKeyValueService(), txManager.getTimestampService(), false), new TargetedSweepFollower(ImmutableList.of(FOLLOWER), txManager)); sweeper.runInBackground(); return sweeper; }