@Override public void put(TableReference tableRef, Map<Cell, byte[]> values) { super.put(tableRef, values); addToCache(tableRef, values); }
@Override public void put(TableReference tableRef, Map<Cell, byte[]> values) { validateWrites(tableRef, values); super.put(tableRef, values); }
private <T, E extends Exception> TransactionTask<T, E> wrapTaskIfNecessary( TransactionTask<T, E> task, LockToken immutableTsLock) { if (taskWrappingIsNecessary()) { return new LockCheckingTransactionTask<>(task, timelockService, immutableTsLock); } return task; }
@Override public <T, E extends Exception> T runTaskWithLocksWithRetry( Iterable<HeldLocksToken> lockTokens, Supplier<LockRequest> lockSupplier, LockAwareTransactionTask<T, E> task) throws E, InterruptedException { checkOpen(); Supplier<AdvisoryLocksCondition> conditionSupplier = AdvisoryLockConditionSuppliers.get(getLockService(), lockTokens, lockSupplier); return runTaskWithConditionWithRetry(conditionSupplier, (transaction, condition) -> task.execute(transaction, condition.getLocks())); }
@Override protected void throwIfReadWriteConflictForSerializable(long commitTimestamp) { Transaction ro = getReadOnlyTransaction(commitTimestamp); verifyRanges(ro); verifyColumnRanges(ro); verifyCells(ro); verifyRows(ro); }
@Override public void throwIfConditionInvalid(long timestamp) { externalLocksCondition.throwIfConditionInvalid(timestamp); transactionLocksCondition.throwIfConditionInvalid(timestamp); }
@Override public Transaction createNewTransaction() { return wrap(delegate.createNewTransaction()); }
@Override ConflictDetectionManager getConflictDetectionManager() { return TestConflictDetectionManagers.createWithStaticConflictDetection(getConflictHandlerWithOverrides()); }
private void ensureUncommitted() { if (!isUncommitted()) { throw new CommittedTransactionException(); } }
@Override public Transaction commitAndStartNewTransaction(Transaction txn) { return wrap(delegate.commitAndStartNewTransaction(txn)); }
public static SweepStrategyManager completelyConservative(KeyValueService kvs) { return new SweepStrategyManager(getConservativeManager(kvs)); }
public static ConflictDetectionManager createWithNoConflictDetection() { return new ConflictDetectionManager( new CacheLoader<TableReference, ConflictHandler>() { @Override public ConflictHandler load(TableReference tableReference) throws Exception { return ConflictHandler.IGNORE_ALL; } }); }
@Override public boolean isInitialized() { assertOpen(); return status == State.READY && isInitializedInternal(); }
public static SweepStrategyManager createDefault(KeyValueService kvs) { return new SweepStrategyManager(getSweepStrategySupplier(kvs)); }
private static RecomputingSupplier<Map<TableReference, SweepStrategy>> getSweepStrategySupplier(final KeyValueService keyValueService) { return RecomputingSupplier.create(() -> getSweepStrategies(keyValueService)); }
private void reachedEndOfRange(TableReference table, RangeRequest range) { if (!isSerializableTable(table)) { return; } setRangeEnd(table, range, PtBytes.EMPTY_BYTE_ARRAY); }
private void reachedEndOfColumnRange( TableReference table, byte[] row, BatchColumnRangeSelection columnRangeSelection) { if (!isSerializableTable(table)) { return; } setColumnRangeEnd(table, row, columnRangeSelection, PtBytes.EMPTY_BYTE_ARRAY); }
InitializeCheckingWrapper(TransactionManager manager, Supplier<Boolean> initializationPrerequisite, Callback<TransactionManager> callBack, ScheduledExecutorService initializer) { this.txManager = manager; this.initializationPrerequisite = initializationPrerequisite; this.callback = callBack; this.executorService = initializer; runCallbackIfInitializedOrScheduleForLater(this::attemptCallbackSynchronously); }
@Override protected TransactionManager getManager() { // create new transaction manager every time because some tests close it return createAndRegisterManager(); }