This is an automated email from the ASF dual-hosted git repository.
vpyatkov pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new d9c4e9c243 IGNITE-23124 Configurable deadlock prevention policies and
retry count after LockException (#4590)
d9c4e9c243 is described below
commit d9c4e9c2435d06eee6806057541cb2fdbf7fe5c0
Author: Denis Chudov <[email protected]>
AuthorDate: Fri Oct 25 11:06:50 2024 +0300
IGNITE-23124 Configurable deadlock prevention policies and retry count
after LockException (#4590)
---
.../ignite/client/fakes/FakeIgniteTables.java | 10 +-
.../ignite/internal/index/IndexManagerTest.java | 10 +-
.../ignite/internal/replicator/ReplicaService.java | 5 +-
.../ReplicationConfigurationSchema.java | 4 +
.../internal/benchmark/LockManagerBenchmark.java | 2 +
.../org/apache/ignite/internal/app/IgniteImpl.java | 8 +-
.../exec/ExecutableTableRegistrySelfTest.java | 10 +-
.../apache/ignite/distributed/ItLockTableTest.java | 4 +-
.../rebalance/ItRebalanceDistributedTest.java | 2 +-
.../ignite/internal/table/ItColocationTest.java | 10 +-
.../internal/table/InteropOperationsTest.java | 10 +-
.../internal/table/TableKvOperationsTestBase.java | 10 +-
.../table/distributed/SortedIndexLockerTest.java | 10 +-
.../PartitionReplicaListenerIndexLockingTest.java | 9 +-
...itionReplicaListenerSortedIndexLockingTest.java | 9 +-
.../replication/PartitionReplicaListenerTest.java | 9 +-
.../org/apache/ignite/internal/tx/LockManager.java | 7 ++
...adlockPreventionPolicyConfigurationSchema.java} | 25 ++--
.../TransactionConfigurationSchema.java | 4 +
.../tx/impl/DeadlockPreventionPolicyImpl.java | 92 +++++++++++++++
.../ignite/internal/tx/impl/HeapLockManager.java | 47 ++++----
.../ignite/internal/tx/impl/TxManagerImpl.java | 8 ++
.../tx/AbstractDeadlockPreventionTest.java | 3 +-
.../ignite/internal/tx/AbstractLockingTest.java | 7 ++
.../internal/tx/CoarseGrainedLockManagerTest.java | 8 +-
.../DeadlockPreventionPolicyConfigurationTest.java | 130 +++++++++++++++++++++
.../internal/tx/HeapLockManagerEventsTest.java | 2 +-
.../ignite/internal/tx/HeapLockManagerTest.java | 4 +-
.../internal/tx/NoWaitDeadlockPreventionTest.java | 12 +-
.../tx/ReversedDeadlockPreventionTest.java | 17 +--
.../internal/tx/TimeoutDeadlockPreventionTest.java | 9 +-
.../apache/ignite/internal/tx/TxManagerTest.java | 9 +-
.../internal/tx/impl/OrphanDetectorTest.java | 9 +-
33 files changed, 424 insertions(+), 91 deletions(-)
diff --git
a/modules/client/src/test/java/org/apache/ignite/client/fakes/FakeIgniteTables.java
b/modules/client/src/test/java/org/apache/ignite/client/fakes/FakeIgniteTables.java
index 20f4d38c2a..c3c062bcc2 100644
---
a/modules/client/src/test/java/org/apache/ignite/client/fakes/FakeIgniteTables.java
+++
b/modules/client/src/test/java/org/apache/ignite/client/fakes/FakeIgniteTables.java
@@ -39,7 +39,9 @@ import
org.apache.ignite.internal.table.StreamerReceiverRunner;
import org.apache.ignite.internal.table.TableImpl;
import org.apache.ignite.internal.table.TableViewInternal;
import org.apache.ignite.internal.table.distributed.schema.SchemaVersions;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.type.NativeTypes;
import org.apache.ignite.lang.IgniteException;
import org.apache.ignite.sql.IgniteSql;
@@ -226,7 +228,7 @@ public class FakeIgniteTables implements
IgniteTablesInternal {
return new TableImpl(
new FakeInternalTable(name, id, keyExtractor, compute,
placementDriver),
schemaReg,
- new HeapLockManager(),
+ lockManager(),
new SchemaVersions() {
@Override
public CompletableFuture<Integer>
schemaVersionAt(HybridTimestamp timestamp, int tableId) {
@@ -243,6 +245,12 @@ public class FakeIgniteTables implements
IgniteTablesInternal {
);
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
/**
* Gets the schema.
*
diff --git
a/modules/index/src/test/java/org/apache/ignite/internal/index/IndexManagerTest.java
b/modules/index/src/test/java/org/apache/ignite/internal/index/IndexManagerTest.java
index c67f6d3bb8..dc5e28a437 100644
---
a/modules/index/src/test/java/org/apache/ignite/internal/index/IndexManagerTest.java
+++
b/modules/index/src/test/java/org/apache/ignite/internal/index/IndexManagerTest.java
@@ -78,7 +78,9 @@ import
org.apache.ignite.internal.table.distributed.schema.ConstantSchemaVersion
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
import org.apache.ignite.internal.testframework.WorkDirectory;
import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.sql.IgniteSql;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
@@ -202,7 +204,7 @@ public class IndexManagerTest extends
BaseIgniteAbstractTest {
return spy(new TableImpl(
internalTable,
- new HeapLockManager(),
+ lockManager(),
new ConstantSchemaVersions(1),
marshallers,
mock(IgniteSql.class),
@@ -210,6 +212,12 @@ public class IndexManagerTest extends
BaseIgniteAbstractTest {
));
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
private int tableId() {
return getTableIdStrict(catalogManager, TABLE_NAME, clock.nowLong());
}
diff --git
a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
index b9c76dfeb6..6af9d8bc4a 100644
---
a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
+++
b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
@@ -55,9 +55,6 @@ import org.jetbrains.annotations.TestOnly;
/** The service is intended to execute requests on replicas. */
public class ReplicaService {
- /** Retry timeout. */
- private static final int RETRY_TIMEOUT_MILLIS = 10;
-
/** Message service. */
private final MessagingService messagingService;
@@ -244,7 +241,7 @@ public class ReplicaService {
retryExecutor.schedule(
// Need to resubmit again to pool which is
valid for synchronous IO execution.
() ->
partitionOperationsExecutor.execute(() ->
res.completeExceptionally(errResp.throwable())),
- RETRY_TIMEOUT_MILLIS, MILLISECONDS);
+
replicationConfiguration.replicaOperationRetryInterval().value(), MILLISECONDS);
} else {
res.completeExceptionally(errResp.throwable());
}
diff --git
a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/configuration/ReplicationConfigurationSchema.java
b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/configuration/ReplicationConfigurationSchema.java
index 207d35af8b..de6316a2c6 100644
---
a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/configuration/ReplicationConfigurationSchema.java
+++
b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/configuration/ReplicationConfigurationSchema.java
@@ -50,4 +50,8 @@ public class ReplicationConfigurationSchema {
@Value(hasDefault = true)
@Range(min = 2000, max = 120000)
public long leaseExpirationInterval = 5_000;
+
+ @Value(hasDefault = true)
+ @Range(max = 10_000)
+ public int replicaOperationRetryInterval = 10;
}
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/LockManagerBenchmark.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/LockManagerBenchmark.java
index 1680ff2c34..33f948b1a4 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/LockManagerBenchmark.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/LockManagerBenchmark.java
@@ -29,6 +29,7 @@ import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.LockMode;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
@@ -60,6 +61,7 @@ public class LockManagerBenchmark {
@Setup
public void setUp() {
lockManager = new HeapLockManager();
+ ((HeapLockManager) lockManager).start(new
WaitDieDeadlockPreventionPolicy());
generator = new TransactionIdGenerator(0);
clock = new TestHybridClock(() -> 0L);
}
diff --git
a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index ce579ed2ef..a23c6301cf 100644
---
a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++
b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -591,8 +591,6 @@ public class IgniteImpl implements Ignite {
failureManager
);
- LockManager lockMgr = new HeapLockManager();
-
MessagingService messagingServiceReturningToStorageOperationsPool =
new JumpToExecutorByConsistentIdAfterSend(
clusterSvc.messagingService(),
name,
@@ -763,6 +761,8 @@ public class IgniteImpl implements Ignite {
replicationConfig
);
+ TransactionConfiguration txConfig =
clusterConfigRegistry.getConfiguration(TransactionExtensionConfiguration.KEY).transaction();
+
ReplicaService replicaSvc = new ReplicaService(
messagingServiceReturningToStorageOperationsPool,
clock,
@@ -893,8 +893,6 @@ public class IgniteImpl implements Ignite {
schemaSyncService
);
- TransactionConfiguration txConfig =
clusterConfigRegistry.getConfiguration(TransactionExtensionConfiguration.KEY).transaction();
-
indexNodeFinishedRwTransactionsChecker = new
IndexNodeFinishedRwTransactionsChecker(
catalogManager,
clusterSvc.messagingService(),
@@ -928,6 +926,8 @@ public class IgniteImpl implements Ignite {
var transactionInflights = new
TransactionInflights(placementDriverMgr.placementDriver(), clockService);
+ LockManager lockMgr = new HeapLockManager();
+
// TODO: IGNITE-19344 - use nodeId that is validated on join (and
probably generated differently).
txManager = new TxManagerImpl(
name,
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
index 1f9519384f..aabe02c006 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/ExecutableTableRegistrySelfTest.java
@@ -46,7 +46,9 @@ import
org.apache.ignite.internal.table.distributed.TableManager;
import
org.apache.ignite.internal.table.distributed.schema.ConstantSchemaVersions;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
import org.apache.ignite.internal.testframework.IgniteTestUtils;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.type.NativeTypes;
import org.apache.ignite.sql.IgniteSql;
import org.junit.jupiter.api.Test;
@@ -148,7 +150,7 @@ public class ExecutableTableRegistrySelfTest extends
BaseIgniteAbstractTest {
int schemaVersion = 1;
int tableVersion = 10;
- TableImpl table = new TableImpl(internalTable, schemaRegistry, new
HeapLockManager(), new ConstantSchemaVersions(tableVersion),
+ TableImpl table = new TableImpl(internalTable, schemaRegistry,
lockManager(), new ConstantSchemaVersions(tableVersion),
mock(IgniteSql.class), -1);
SchemaDescriptor schemaDescriptor = newDescriptor(schemaVersion);
@@ -167,5 +169,11 @@ public class ExecutableTableRegistrySelfTest extends
BaseIgniteAbstractTest {
return registry.getTable(schemaVersion, tableId);
}
+
+ private LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
}
}
diff --git
a/modules/table/src/integrationTest/java/org/apache/ignite/distributed/ItLockTableTest.java
b/modules/table/src/integrationTest/java/org/apache/ignite/distributed/ItLockTableTest.java
index ee48aa527b..e219facc70 100644
---
a/modules/table/src/integrationTest/java/org/apache/ignite/distributed/ItLockTableTest.java
+++
b/modules/table/src/integrationTest/java/org/apache/ignite/distributed/ItLockTableTest.java
@@ -40,7 +40,6 @@ import
org.apache.ignite.internal.schema.configuration.GcConfiguration;
import
org.apache.ignite.internal.schema.configuration.StorageUpdateConfiguration;
import org.apache.ignite.internal.table.TableViewInternal;
import org.apache.ignite.internal.testframework.IgniteAbstractTest;
-import org.apache.ignite.internal.tx.DeadlockPreventionPolicy;
import org.apache.ignite.internal.tx.HybridTimestampTracker;
import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
@@ -93,7 +92,7 @@ public class ItLockTableTest extends IgniteAbstractTest {
@InjectConfiguration
protected static GcConfiguration gcConfig;
- @InjectConfiguration
+ @InjectConfiguration("mock: { deadlockPreventionPolicy: { waitTimeout: -1,
txIdComparator: NONE } }")
protected static TransactionConfiguration txConfiguration;
@InjectConfiguration
@@ -146,7 +145,6 @@ public class ItLockTableTest extends IgniteAbstractTest {
clusterService,
replicaSvc,
new HeapLockManager(
- DeadlockPreventionPolicy.NO_OP,
HeapLockManager.SLOTS,
CACHE_SIZE),
clockService,
diff --git
a/modules/table/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
b/modules/table/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
index aba421593c..3eb2f64b2e 100644
---
a/modules/table/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
+++
b/modules/table/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
@@ -1043,7 +1043,7 @@ public class ItRebalanceDistributedTest extends
BaseIgniteAbstractTest {
private final ClusterService clusterService;
- private final LockManager lockManager;
+ private final HeapLockManager lockManager;
private final TxManager txManager;
diff --git
a/modules/table/src/integrationTest/java/org/apache/ignite/internal/table/ItColocationTest.java
b/modules/table/src/integrationTest/java/org/apache/ignite/internal/table/ItColocationTest.java
index fc12949c07..de0e2e1a4b 100644
---
a/modules/table/src/integrationTest/java/org/apache/ignite/internal/table/ItColocationTest.java
+++
b/modules/table/src/integrationTest/java/org/apache/ignite/internal/table/ItColocationTest.java
@@ -96,6 +96,7 @@ import
org.apache.ignite.internal.table.impl.DummyInternalTableImpl;
import org.apache.ignite.internal.table.impl.DummySchemaManagerImpl;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
import org.apache.ignite.internal.tx.HybridTimestampTracker;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.TxManager;
import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
@@ -103,6 +104,7 @@ import
org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
import org.apache.ignite.internal.tx.impl.TransactionInflights;
import org.apache.ignite.internal.tx.impl.TxManagerImpl;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import
org.apache.ignite.internal.tx.storage.state.test.TestTxStateTableStorage;
import org.apache.ignite.internal.tx.test.TestLocalRwTxCounter;
import org.apache.ignite.internal.tx.test.TestTransactionIds;
@@ -404,11 +406,17 @@ public class ItColocationTest extends
BaseIgniteAbstractTest {
schemaRegistry = new DummySchemaManagerImpl(schema);
- tbl = new TableImpl(intTable, schemaRegistry, new HeapLockManager(),
new ConstantSchemaVersions(1), mock(IgniteSql.class), -1);
+ tbl = new TableImpl(intTable, schemaRegistry, lockManager(), new
ConstantSchemaVersions(1), mock(IgniteSql.class), -1);
marshaller = new TupleMarshallerImpl(schema);
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
private Tuple createTuple(int k, NativeTypeSpec t0, NativeTypeSpec t1) {
return Tuple.create()
.set("ID", 1L)
diff --git
a/modules/table/src/test/java/org/apache/ignite/internal/table/InteropOperationsTest.java
b/modules/table/src/test/java/org/apache/ignite/internal/table/InteropOperationsTest.java
index c22651a030..0c7404a250 100644
---
a/modules/table/src/test/java/org/apache/ignite/internal/table/InteropOperationsTest.java
+++
b/modules/table/src/test/java/org/apache/ignite/internal/table/InteropOperationsTest.java
@@ -53,8 +53,10 @@ import
org.apache.ignite.internal.table.distributed.schema.SchemaVersions;
import org.apache.ignite.internal.table.impl.DummyInternalTableImpl;
import org.apache.ignite.internal.table.impl.DummySchemaManagerImpl;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.type.NativeType;
import org.apache.ignite.internal.type.NativeTypes;
import org.apache.ignite.sql.IgniteSql;
@@ -140,7 +142,7 @@ public class InteropOperationsTest extends
BaseIgniteAbstractTest {
SchemaVersions schemaVersions = new
ConstantSchemaVersions(schemaVersion);
- table = new TableImpl(intTable, schemaRegistry, new HeapLockManager(),
schemaVersions, mock(IgniteSql.class), -1);
+ table = new TableImpl(intTable, schemaRegistry, lockManager(),
schemaVersions, mock(IgniteSql.class), -1);
kvBinView = table.keyValueView();
kvView = table.keyValueView(Mapper.of(Long.class, "id"),
Mapper.of(Value.class));
@@ -148,6 +150,12 @@ public class InteropOperationsTest extends
BaseIgniteAbstractTest {
rView = table.recordView(Mapper.of(Row.class));
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
/**
* Validate all types are tested.
*/
diff --git
a/modules/table/src/test/java/org/apache/ignite/internal/table/TableKvOperationsTestBase.java
b/modules/table/src/test/java/org/apache/ignite/internal/table/TableKvOperationsTestBase.java
index 8f80e343c9..e7669244d2 100644
---
a/modules/table/src/test/java/org/apache/ignite/internal/table/TableKvOperationsTestBase.java
+++
b/modules/table/src/test/java/org/apache/ignite/internal/table/TableKvOperationsTestBase.java
@@ -33,8 +33,10 @@ import
org.apache.ignite.internal.table.distributed.schema.SchemaVersions;
import org.apache.ignite.internal.table.impl.DummyInternalTableImpl;
import org.apache.ignite.internal.table.impl.DummySchemaManagerImpl;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.sql.IgniteSql;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -70,13 +72,19 @@ abstract class TableKvOperationsTestBase extends
BaseIgniteAbstractTest {
return new TableImpl(
internalTable,
new DummySchemaManagerImpl(schema),
- new HeapLockManager(),
+ lockManager(),
schemaVersions,
mock(IgniteSql.class),
-1
);
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
protected final DummyInternalTableImpl
createInternalTable(SchemaDescriptor schema) {
return new DummyInternalTableImpl(replicaService, schema,
txConfiguration, storageUpdateConfiguration);
}
diff --git
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/SortedIndexLockerTest.java
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/SortedIndexLockerTest.java
index f6ed8fd620..7ea553adda 100644
---
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/SortedIndexLockerTest.java
+++
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/SortedIndexLockerTest.java
@@ -36,7 +36,9 @@ import
org.apache.ignite.internal.storage.index.StorageSortedIndexDescriptor.Sto
import org.apache.ignite.internal.storage.index.impl.TestSortedIndexStorage;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
import org.apache.ignite.internal.tx.Lock;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.tx.test.TestTransactionIds;
import org.apache.ignite.internal.type.NativeTypes;
import org.jetbrains.annotations.Nullable;
@@ -61,11 +63,17 @@ class SortedIndexLockerTest extends BaseIgniteAbstractTest {
);
indexStorage.destroy();
- SortedIndexLocker locker = new SortedIndexLocker(1, PARTITION_ID, new
HeapLockManager(), indexStorage, row -> binaryTuple, false);
+ SortedIndexLocker locker = new SortedIndexLocker(1, PARTITION_ID,
lockManager(), indexStorage, row -> binaryTuple, false);
UUID txId =
TestTransactionIds.TRANSACTION_ID_GENERATOR.transactionIdFor(clock.now());
CompletableFuture<@Nullable Lock> lockFuture =
locker.locksForInsert(txId, mock(BinaryRow.class), new RowId(PARTITION_ID));
assertThat(lockFuture, willBe(nullValue()));
}
+
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
}
diff --git
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerIndexLockingTest.java
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerIndexLockingTest.java
index 568bd009a9..7ab9e26d73 100644
---
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerIndexLockingTest.java
+++
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerIndexLockingTest.java
@@ -116,6 +116,7 @@ import org.apache.ignite.internal.tx.TxState;
import org.apache.ignite.internal.tx.TxStateMeta;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.tx.storage.state.test.TestTxStateStorage;
import org.apache.ignite.internal.tx.test.TestTransactionIds;
import org.apache.ignite.internal.type.NativeTypes;
@@ -142,7 +143,7 @@ public class PartitionReplicaListenerIndexLockingTest
extends IgniteAbstractTest
private static final UUID TRANSACTION_ID =
TestTransactionIds.newTransactionId();
private static final HybridClock CLOCK = new HybridClockImpl();
private static final ClockService CLOCK_SERVICE = new
TestClockService(CLOCK);
- private static final LockManager LOCK_MANAGER = new HeapLockManager();
+ private static final LockManager LOCK_MANAGER = lockManager();
private static final TablePartitionId PARTITION_ID = new
TablePartitionId(TABLE_ID, PART_ID);
private static final PartitionReplicationMessagesFactory
TABLE_MESSAGES_FACTORY = new PartitionReplicationMessagesFactory();
private static final TestMvPartitionStorage TEST_MV_PARTITION_STORAGE =
new TestMvPartitionStorage(PART_ID);
@@ -311,6 +312,12 @@ public class PartitionReplicaListenerIndexLockingTest
extends IgniteAbstractTest
return txManager;
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
@BeforeEach
public void beforeTest() {
((TestHashIndexStorage) pkStorage.get().storage()).clear();
diff --git
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerSortedIndexLockingTest.java
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerSortedIndexLockingTest.java
index 417d81e429..af785a9569 100644
---
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerSortedIndexLockingTest.java
+++
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerSortedIndexLockingTest.java
@@ -111,6 +111,7 @@ import org.apache.ignite.internal.tx.TxState;
import org.apache.ignite.internal.tx.TxStateMeta;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.tx.storage.state.test.TestTxStateStorage;
import org.apache.ignite.internal.tx.test.TestTransactionIds;
import org.apache.ignite.internal.type.NativeTypes;
@@ -135,7 +136,7 @@ public class PartitionReplicaListenerSortedIndexLockingTest
extends IgniteAbstra
private static final UUID TRANSACTION_ID =
TestTransactionIds.newTransactionId();
private static final HybridClock CLOCK = new HybridClockImpl();
private static final ClockService CLOCK_SERVICE = new
TestClockService(CLOCK);
- private static final LockManager LOCK_MANAGER = new HeapLockManager();
+ private static final LockManager LOCK_MANAGER = lockManager();
private static final TablePartitionId PARTITION_ID = new
TablePartitionId(TABLE_ID, PART_ID);
private static final PartitionReplicationMessagesFactory
TABLE_MESSAGES_FACTORY = new PartitionReplicationMessagesFactory();
private static final TestMvPartitionStorage TEST_MV_PARTITION_STORAGE =
new TestMvPartitionStorage(PART_ID);
@@ -286,6 +287,12 @@ public class
PartitionReplicaListenerSortedIndexLockingTest extends IgniteAbstra
LOCK_MANAGER.releaseAll(TRANSACTION_ID);
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
/** Verifies the mode in which the lock was acquired on the index key for
a particular operation. */
@ParameterizedTest
@MethodSource("readWriteSingleTestArguments")
diff --git
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java
index 9dd710bcd8..340c7bd94e 100644
---
a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java
+++
b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/replication/PartitionReplicaListenerTest.java
@@ -218,6 +218,7 @@ import
org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
import org.apache.ignite.internal.tx.impl.HeapLockManager;
import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
import org.apache.ignite.internal.tx.impl.TxMessageSender;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.tx.message.TransactionMetaMessage;
import org.apache.ignite.internal.tx.message.TxFinishReplicaRequest;
import org.apache.ignite.internal.tx.message.TxMessagesFactory;
@@ -287,7 +288,7 @@ public class PartitionReplicaListenerTest extends
IgniteAbstractTest {
/** The storage stores partition data. */
private final TestMvPartitionStorage testMvPartitionStorage = new
TestMvPartitionStorage(PART_ID);
- private final LockManager lockManager = new HeapLockManager();
+ private final LockManager lockManager = lockManager();
private final Function<Command, CompletableFuture<?>>
defaultMockRaftFutureClosure = cmd -> {
if (cmd instanceof WriteIntentSwitchCommand) {
@@ -662,6 +663,12 @@ public class PartitionReplicaListenerTest extends
IgniteAbstractTest {
Mockito.framework().clearInlineMocks();
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
private static SchemaDescriptor schemaDescriptorWith(int ver) {
return new SchemaDescriptor(ver, new Column[]{
new Column("intKey".toUpperCase(Locale.ROOT),
NativeTypes.INT32, false),
diff --git
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/LockManager.java
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/LockManager.java
index 65e6132cd6..e696997f45 100644
---
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/LockManager.java
+++
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/LockManager.java
@@ -28,6 +28,13 @@ import org.jetbrains.annotations.TestOnly;
/** Lock manager allows to acquire locks and release locks and supports
deadlock prevention by transaction id ordering. */
public interface LockManager extends EventProducer<LockEvent,
LockEventParameters> {
+ /**
+ * Start the lock manager.
+ *
+ * @param deadlockPreventionPolicy Deadlock prevention policy.
+ */
+ void start(DeadlockPreventionPolicy deadlockPreventionPolicy);
+
/**
* Attempts to acquire a lock for the specified {@code lockKey} in
specified {@code lockMode}.
*
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/DeadlockPreventionPolicyConfigurationSchema.java
similarity index 60%
copy from
modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
copy to
modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/DeadlockPreventionPolicyConfigurationSchema.java
index 43b2baacf6..4058823673 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
+++
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/DeadlockPreventionPolicyConfigurationSchema.java
@@ -15,22 +15,21 @@
* limitations under the License.
*/
-package org.apache.ignite.internal.tx;
+package org.apache.ignite.internal.tx.configuration;
-import org.apache.ignite.internal.tx.impl.HeapLockManager;
-import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
+import org.apache.ignite.configuration.annotation.Config;
+import org.apache.ignite.configuration.annotation.Value;
+import org.apache.ignite.configuration.validation.OneOf;
/**
- * Test class for {@link HeapLockManager}.
+ * Configuration schema for deadlock prevention policy.
*/
-public class HeapLockManagerTest extends AbstractLockManagerTest {
- @Override
- protected LockManager newInstance() {
- return new HeapLockManager(new WaitDieDeadlockPreventionPolicy());
- }
+@Config
+public class DeadlockPreventionPolicyConfigurationSchema {
+ @OneOf({"NATURAL", "REVERSED", "NONE"})
+ @Value(hasDefault = true)
+ public String txIdComparator = "NATURAL";
- @Override
- protected LockKey lockKey() {
- return new LockKey(0, "test");
- }
+ @Value(hasDefault = true)
+ public long waitTimeout = 0;
}
diff --git
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/TransactionConfigurationSchema.java
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/TransactionConfigurationSchema.java
index dfdef9d133..0a619c7b90 100644
---
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/TransactionConfigurationSchema.java
+++
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/configuration/TransactionConfigurationSchema.java
@@ -19,6 +19,7 @@ package org.apache.ignite.internal.tx.configuration;
import java.util.concurrent.TimeUnit;
import org.apache.ignite.configuration.annotation.Config;
+import org.apache.ignite.configuration.annotation.ConfigValue;
import org.apache.ignite.configuration.annotation.Value;
import org.apache.ignite.configuration.validation.Range;
@@ -54,4 +55,7 @@ public class TransactionConfigurationSchema {
@Value(hasDefault = true)
@Range(min = 1000)
public long rpcTimeout = TimeUnit.SECONDS.toMillis(60);
+
+ @ConfigValue
+ public DeadlockPreventionPolicyConfigurationSchema
deadlockPreventionPolicy;
}
diff --git
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/DeadlockPreventionPolicyImpl.java
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/DeadlockPreventionPolicyImpl.java
new file mode 100644
index 0000000000..ba696f37f7
--- /dev/null
+++
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/DeadlockPreventionPolicyImpl.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.tx.impl;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Comparator;
+import java.util.UUID;
+import org.apache.ignite.internal.tx.DeadlockPreventionPolicy;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Implementation of {@link DeadlockPreventionPolicy} that allows to set its
parameters directly in the constructor, so it is able to
+ * provide different policies' behaviour such as wait-die, reversed wait-die,
timeout wait, no-wait, etc.
+ */
+public class DeadlockPreventionPolicyImpl implements DeadlockPreventionPolicy {
+ private final Comparator<UUID> txIdComparator;
+
+ private final long waitTimeout;
+
+ /**
+ * Constructor.
+ *
+ * @param txIdComparator Comparator name.
+ * @param waitTimeout Wait timeout.
+ */
+ public DeadlockPreventionPolicyImpl(String txIdComparator, long
waitTimeout) {
+ this(TxIdComparators.valueOf(requireNonNull(txIdComparator)),
waitTimeout);
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param txIdComparator Comparator name as {@link TxIdComparators}
element.
+ * @param waitTimeout Wait timeout.
+ */
+ public DeadlockPreventionPolicyImpl(TxIdComparators txIdComparator, long
waitTimeout) {
+ switch (txIdComparator) {
+ case NATURAL: {
+ this.txIdComparator = new TxIdPriorityComparator();
+ break;
+ }
+ case REVERSE: {
+ this.txIdComparator = new TxIdPriorityComparator().reversed();
+ break;
+ }
+ case NONE: {
+ this.txIdComparator = null;
+ break;
+ }
+ default: {
+ throw new IllegalArgumentException("Unknown comparator type: "
+ txIdComparator);
+ }
+ }
+
+ this.waitTimeout = waitTimeout;
+ }
+
+ @Override
+ public @Nullable Comparator<UUID> txIdComparator() {
+ return txIdComparator;
+ }
+
+ @Override
+ public long waitTimeout() {
+ return waitTimeout;
+ }
+
+ /**
+ * Enum of names of transaction ID comparators.
+ */
+ public enum TxIdComparators {
+ NATURAL,
+ REVERSE,
+ NONE
+ }
+}
diff --git
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
index 60ddf4dad1..b74b9029bb 100644
---
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
+++
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
@@ -84,6 +84,12 @@ public class HeapLockManager extends
AbstractEventProducer<LockEvent, LockEventP
*/
private static final int CONCURRENCY = Math.max(1,
Runtime.getRuntime().availableProcessors() / 2);
+ /** Lock map size. */
+ private final int lockMapSize;
+
+ /** Raw slots size. */
+ private final int rawSlotsMaxSize;
+
/**
* Empty slots.
*/
@@ -92,22 +98,22 @@ public class HeapLockManager extends
AbstractEventProducer<LockEvent, LockEventP
/**
* Mapped slots.
*/
- private final ConcurrentHashMap<LockKey, LockState> locks;
+ private ConcurrentHashMap<LockKey, LockState> locks;
/**
* Raw slots.
*/
- private final LockState[] slots;
+ private LockState[] slots;
/**
* The policy.
*/
- private final DeadlockPreventionPolicy deadlockPreventionPolicy;
+ private DeadlockPreventionPolicy deadlockPreventionPolicy;
/**
* Executor that is used to fail waiters after timeout.
*/
- private final Executor delayedExecutor;
+ private Executor delayedExecutor;
/**
* Enlisted transactions.
@@ -123,39 +129,38 @@ public class HeapLockManager extends
AbstractEventProducer<LockEvent, LockEventP
* Constructor.
*/
public HeapLockManager() {
- this(new WaitDieDeadlockPreventionPolicy(), SLOTS, SLOTS);
- }
-
- /**
- * Constructor.
- */
- public HeapLockManager(DeadlockPreventionPolicy deadlockPreventionPolicy) {
- this(deadlockPreventionPolicy, SLOTS, SLOTS);
+ this(SLOTS, SLOTS);
}
/**
* Constructor.
*
- * @param deadlockPreventionPolicy Deadlock prevention policy.
- * @param maxSize Raw slots size.
- * @param mapSize Lock map size.
+ * @param rawSlotsMaxSize Raw slots size.
+ * @param lockMapSize Lock map size.
*/
- public HeapLockManager(DeadlockPreventionPolicy deadlockPreventionPolicy,
int maxSize, int mapSize) {
- if (mapSize > maxSize) {
- throw new IllegalArgumentException("maxSize=" + maxSize + " <
mapSize=" + mapSize);
+ public HeapLockManager(int rawSlotsMaxSize, int lockMapSize) {
+ if (lockMapSize > rawSlotsMaxSize) {
+ throw new IllegalArgumentException("maxSize=" + rawSlotsMaxSize +
" < mapSize=" + lockMapSize);
}
+ this.rawSlotsMaxSize = rawSlotsMaxSize;
+ this.lockMapSize = lockMapSize;
+ }
+
+ @Override
+ public void start(DeadlockPreventionPolicy deadlockPreventionPolicy) {
this.deadlockPreventionPolicy = deadlockPreventionPolicy;
+
this.delayedExecutor = deadlockPreventionPolicy.waitTimeout() > 0
?
CompletableFuture.delayedExecutor(deadlockPreventionPolicy.waitTimeout(),
TimeUnit.MILLISECONDS)
: null;
- locks = new ConcurrentHashMap<>(mapSize);
+ locks = new ConcurrentHashMap<>(lockMapSize);
- LockState[] tmp = new LockState[maxSize];
+ LockState[] tmp = new LockState[rawSlotsMaxSize];
for (int i = 0; i < tmp.length; i++) {
LockState lockState = new LockState();
- if (i < mapSize) {
+ if (i < lockMapSize) {
empty.add(lockState);
}
tmp[i] = lockState;
diff --git
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
index d8bae15056..ba9a931e6d 100644
---
a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
+++
b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
@@ -737,6 +737,14 @@ public class TxManagerImpl implements TxManager,
NetworkMessageHandler {
@Override
public CompletableFuture<Void> startAsync(ComponentContext
componentContext) {
return inBusyLockAsync(busyLock, () -> {
+ var deadlockPreventionPolicy = new DeadlockPreventionPolicyImpl(
+
txConfig.deadlockPreventionPolicy().txIdComparator().value(),
+ txConfig.deadlockPreventionPolicy().waitTimeout().value()
+ );
+
+ // TODO https://issues.apache.org/jira/browse/IGNITE-23539
+ lockManager.start(deadlockPreventionPolicy);
+
localNodeId = topologyService.localMember().id();
messagingService.addMessageHandler(ReplicaMessageGroup.class,
this);
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractDeadlockPreventionTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractDeadlockPreventionTest.java
index dc66dbec6c..631a6fd26d 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractDeadlockPreventionTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractDeadlockPreventionTest.java
@@ -27,7 +27,6 @@ import static org.junit.jupiter.api.Assertions.fail;
import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;
-import org.apache.ignite.internal.tx.impl.HeapLockManager;
import org.junit.jupiter.api.Test;
/**
@@ -38,7 +37,7 @@ public abstract class AbstractDeadlockPreventionTest extends
AbstractLockingTest
@Override
protected LockManager lockManager() {
- return new HeapLockManager(deadlockPreventionPolicy());
+ return lockManager(deadlockPreventionPolicy());
}
@Test
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractLockingTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractLockingTest.java
index e0f2e844a0..45ba36b335 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractLockingTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/AbstractLockingTest.java
@@ -29,6 +29,7 @@ import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import org.apache.ignite.internal.lang.IgniteBiTuple;
+import org.apache.ignite.internal.tx.impl.HeapLockManager;
import org.apache.ignite.internal.tx.test.TestTransactionIds;
/**
@@ -40,6 +41,12 @@ public abstract class AbstractLockingTest {
protected abstract LockManager lockManager();
+ protected static LockManager lockManager(DeadlockPreventionPolicy
deadlockPreventionPolicy) {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(deadlockPreventionPolicy);
+ return lockManager;
+ }
+
protected UUID beginTx() {
return TestTransactionIds.newTransactionId();
}
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/CoarseGrainedLockManagerTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/CoarseGrainedLockManagerTest.java
index d3348e7e06..e71c94a0bd 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/CoarseGrainedLockManagerTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/CoarseGrainedLockManagerTest.java
@@ -33,13 +33,19 @@ import org.junit.jupiter.api.Test;
* Tests coarse lock modes. It allows IX, S locks and upgrade from S to SIX
(S, then IX).
*/
public class CoarseGrainedLockManagerTest {
- private final HeapLockManager lockManager = new HeapLockManager(new
WaitDieDeadlockPreventionPolicy());
+ private final HeapLockManager lockManager = lockManager();
@AfterEach
void after() {
assertTrue(lockManager.isEmpty());
}
+ private static HeapLockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
@Test
public void testSimple() {
UUID older = TestTransactionIds.newTransactionId();
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/DeadlockPreventionPolicyConfigurationTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/DeadlockPreventionPolicyConfigurationTest.java
new file mode 100644
index 0000000000..cee63cf19f
--- /dev/null
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/DeadlockPreventionPolicyConfigurationTest.java
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.tx;
+
+import static
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators.NATURAL;
+import static
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators.NONE;
+import static
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators.REVERSE;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Comparator;
+import java.util.UUID;
+import
org.apache.ignite.internal.configuration.testframework.ConfigurationExtension;
+import
org.apache.ignite.internal.configuration.testframework.InjectConfiguration;
+import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
+import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
+import org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl;
+import
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators;
+import org.apache.ignite.internal.tx.impl.TxIdPriorityComparator;
+import org.jetbrains.annotations.Nullable;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/**
+ * Tests for {@link
org.apache.ignite.internal.tx.configuration.DeadlockPreventionPolicyConfigurationSchema}.
+ */
+@ExtendWith(ConfigurationExtension.class)
+public class DeadlockPreventionPolicyConfigurationTest extends
BaseIgniteAbstractTest {
+ @InjectConfiguration
+ private TransactionConfiguration transactionConfigurationDefault;
+
+ @InjectConfiguration("mock: { deadlockPreventionPolicy: { waitTimeout:
1000, txIdComparator: NATURAL } }")
+ private TransactionConfiguration transactionConfigurationMockedNatural;
+
+ @InjectConfiguration("mock: { deadlockPreventionPolicy: { waitTimeout:
100, txIdComparator: REVERSE } }")
+ private TransactionConfiguration transactionConfigurationMockedReverse;
+
+ @InjectConfiguration("mock: { deadlockPreventionPolicy: { waitTimeout: 0,
txIdComparator: NONE } }")
+ private TransactionConfiguration transactionConfigurationMockedNone;
+
+ @Test
+ public void checkDefaults() {
+ assertEquals(0,
transactionConfigurationDefault.deadlockPreventionPolicy().waitTimeout().value());
+ assertEquals(NATURAL.toString(),
+
transactionConfigurationDefault.deadlockPreventionPolicy().txIdComparator().value());
+
+ assertPolicyIsCorrect(createPolicy(transactionConfigurationDefault),
transactionConfigurationDefault);
+ }
+
+ @Test
+ public void checkMockedNatural() {
+ assertEquals(1000,
transactionConfigurationMockedNatural.deadlockPreventionPolicy().waitTimeout().value());
+ assertEquals(NATURAL.toString(),
+
transactionConfigurationMockedNatural.deadlockPreventionPolicy().txIdComparator().value());
+
+
assertPolicyIsCorrect(createPolicy(transactionConfigurationMockedNatural),
transactionConfigurationMockedNatural);
+ }
+
+ @Test
+ public void checkMockedReverse() {
+ assertEquals(100,
transactionConfigurationMockedReverse.deadlockPreventionPolicy().waitTimeout().value());
+ assertEquals(REVERSE.toString(),
+
transactionConfigurationMockedReverse.deadlockPreventionPolicy().txIdComparator().value());
+
+
assertPolicyIsCorrect(createPolicy(transactionConfigurationMockedReverse),
transactionConfigurationMockedReverse);
+ }
+
+ @Test
+ public void checkMockedNone() {
+ assertEquals(0,
transactionConfigurationMockedNone.deadlockPreventionPolicy().waitTimeout().value());
+ assertEquals(NONE.toString(),
+
transactionConfigurationMockedNone.deadlockPreventionPolicy().txIdComparator().value());
+
+
assertPolicyIsCorrect(createPolicy(transactionConfigurationMockedNone),
transactionConfigurationMockedNone);
+ }
+
+ private void assertPolicyIsCorrect(DeadlockPreventionPolicy policy,
TransactionConfiguration cfg) {
+ assertEquals(cfg.deadlockPreventionPolicy().waitTimeout().value(),
policy.waitTimeout());
+ assertComparatorIsCorrect(policy.txIdComparator(),
cfg.deadlockPreventionPolicy().txIdComparator().value());
+ }
+
+ private DeadlockPreventionPolicy createPolicy(TransactionConfiguration
cfg) {
+ return new DeadlockPreventionPolicyImpl(
+ cfg.deadlockPreventionPolicy().txIdComparator().value(),
+ cfg.deadlockPreventionPolicy().waitTimeout().value()
+ );
+ }
+
+ private void assertComparatorIsCorrect(@Nullable Comparator<UUID>
actualComparator, String configured) {
+ TxIdComparators configuredEnum = TxIdComparators.valueOf(configured);
+
+ if (actualComparator == null) {
+ assertEquals(NONE, configuredEnum);
+ return;
+ }
+
+ TxIdPriorityComparator naturalComparator = new
TxIdPriorityComparator();
+
+ UUID uuid1 = UUID.randomUUID();
+ UUID uuid2;
+
+ do {
+ uuid2 = UUID.randomUUID();
+ } while (naturalComparator.compare(uuid1, uuid2) == 0);
+
+ UUID greater = naturalComparator.compare(uuid1, uuid2) > 0 ? uuid1 :
uuid2;
+ UUID lesser = naturalComparator.compare(uuid1, uuid2) > 0 ? uuid2 :
uuid1;
+
+ int cmp = actualComparator.compare(greater, lesser);
+ if (cmp > 0) {
+ assertEquals(NATURAL, configuredEnum);
+ } else {
+ assertEquals(REVERSE, configuredEnum);
+ }
+ }
+}
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerEventsTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerEventsTest.java
index 3b4621add0..270116c2c4 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerEventsTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerEventsTest.java
@@ -26,6 +26,6 @@ import
org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
public class HeapLockManagerEventsTest extends AbstractLockManagerEventsTest {
@Override
protected LockManager lockManager() {
- return new HeapLockManager(new WaitDieDeadlockPreventionPolicy());
+ return lockManager(new WaitDieDeadlockPreventionPolicy());
}
}
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
index 43b2baacf6..dd641295a2 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java
@@ -26,7 +26,9 @@ import
org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
public class HeapLockManagerTest extends AbstractLockManagerTest {
@Override
protected LockManager newInstance() {
- return new HeapLockManager(new WaitDieDeadlockPreventionPolicy());
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
}
@Override
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/NoWaitDeadlockPreventionTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/NoWaitDeadlockPreventionTest.java
index 6319536ee7..d84c0969ed 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/NoWaitDeadlockPreventionTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/NoWaitDeadlockPreventionTest.java
@@ -23,7 +23,8 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.CompletableFuture;
-import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl;
+import
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators;
import org.junit.jupiter.api.Test;
/**
@@ -32,17 +33,12 @@ import org.junit.jupiter.api.Test;
*/
public class NoWaitDeadlockPreventionTest extends AbstractLockingTest {
DeadlockPreventionPolicy deadlockPreventionPolicy() {
- return new DeadlockPreventionPolicy() {
- @Override
- public long waitTimeout() {
- return 0;
- }
- };
+ return new DeadlockPreventionPolicyImpl(TxIdComparators.NONE, 0);
}
@Override
protected LockManager lockManager() {
- return new HeapLockManager(deadlockPreventionPolicy());
+ return lockManager(deadlockPreventionPolicy());
}
@Test
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/ReversedDeadlockPreventionTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/ReversedDeadlockPreventionTest.java
index b4b7419f48..75ae158c19 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/ReversedDeadlockPreventionTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/ReversedDeadlockPreventionTest.java
@@ -22,11 +22,10 @@ import static
org.apache.ignite.internal.testframework.matchers.CompletableFutur
import static
org.apache.ignite.internal.testframework.matchers.CompletableFutureMatcher.willSucceedFast;
import static org.hamcrest.MatcherAssert.assertThat;
-import java.util.Comparator;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
-import org.apache.ignite.internal.tx.impl.TxIdPriorityComparator;
-import org.jetbrains.annotations.Nullable;
+import org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl;
+import
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -54,17 +53,7 @@ public class ReversedDeadlockPreventionTest extends
AbstractDeadlockPreventionTe
@Override
protected DeadlockPreventionPolicy deadlockPreventionPolicy() {
- return new DeadlockPreventionPolicy() {
- @Override
- public @Nullable Comparator<UUID> txIdComparator() {
- return new TxIdPriorityComparator().reversed();
- }
-
- @Override
- public long waitTimeout() {
- return 0;
- }
- };
+ return new DeadlockPreventionPolicyImpl(TxIdComparators.REVERSE, 0);
}
@Test
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TimeoutDeadlockPreventionTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TimeoutDeadlockPreventionTest.java
index 05af5790ba..d57610d308 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TimeoutDeadlockPreventionTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TimeoutDeadlockPreventionTest.java
@@ -23,6 +23,8 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl;
+import
org.apache.ignite.internal.tx.impl.DeadlockPreventionPolicyImpl.TxIdComparators;
import org.junit.jupiter.api.Test;
/**
@@ -31,12 +33,7 @@ import org.junit.jupiter.api.Test;
public class TimeoutDeadlockPreventionTest extends
AbstractDeadlockPreventionTest {
@Override
protected DeadlockPreventionPolicy deadlockPreventionPolicy() {
- return new DeadlockPreventionPolicy() {
- @Override
- public long waitTimeout() {
- return 200;
- }
- };
+ return new DeadlockPreventionPolicyImpl(TxIdComparators.NONE, 200);
}
@Test
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TxManagerTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TxManagerTest.java
index 3afafbaa0f..0cf3938689 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TxManagerTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/TxManagerTest.java
@@ -84,6 +84,7 @@ import
org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
import org.apache.ignite.internal.tx.impl.TransactionInflights;
import org.apache.ignite.internal.tx.impl.TxManagerImpl;
+import org.apache.ignite.internal.tx.impl.WaitDieDeadlockPreventionPolicy;
import org.apache.ignite.internal.tx.message.TxFinishReplicaRequest;
import org.apache.ignite.internal.tx.test.TestLocalRwTxCounter;
import org.apache.ignite.internal.tx.test.TestTransactionIds;
@@ -158,7 +159,7 @@ public class TxManagerTest extends IgniteAbstractTest {
txConfiguration,
clusterService,
replicaService,
- new HeapLockManager(),
+ lockManager(),
clockService,
new TransactionIdGenerator(0xdeadbeef),
placementDriver,
@@ -172,6 +173,12 @@ public class TxManagerTest extends IgniteAbstractTest {
assertThat(txManager.startAsync(new ComponentContext()),
willCompleteSuccessfully());
}
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
@AfterEach
public void tearDown() {
txManager.beforeNodeStop();
diff --git
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/impl/OrphanDetectorTest.java
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/impl/OrphanDetectorTest.java
index ea251e430f..f690790339 100644
---
a/modules/transactions/src/test/java/org/apache/ignite/internal/tx/impl/OrphanDetectorTest.java
+++
b/modules/transactions/src/test/java/org/apache/ignite/internal/tx/impl/OrphanDetectorTest.java
@@ -54,6 +54,7 @@ import
org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
import org.apache.ignite.internal.tx.Lock;
import org.apache.ignite.internal.tx.LockException;
import org.apache.ignite.internal.tx.LockKey;
+import org.apache.ignite.internal.tx.LockManager;
import org.apache.ignite.internal.tx.LockMode;
import org.apache.ignite.internal.tx.TxState;
import org.apache.ignite.internal.tx.TxStateMeta;
@@ -87,7 +88,7 @@ public class OrphanDetectorTest extends
BaseIgniteAbstractTest {
@Mock
private PlacementDriver placementDriver;
- private final HeapLockManager lockManager = new HeapLockManager();
+ private final LockManager lockManager = lockManager();
private final HybridClock clock = new HybridClockImpl();
@@ -102,6 +103,12 @@ public class OrphanDetectorTest extends
BaseIgniteAbstractTest {
private TransactionIdGenerator idGenerator;
+ private static LockManager lockManager() {
+ HeapLockManager lockManager = new HeapLockManager();
+ lockManager.start(new WaitDieDeadlockPreventionPolicy());
+ return lockManager;
+ }
+
@BeforeEach
public void setup() {
idGenerator = new TransactionIdGenerator(LOCAL_NODE.name().hashCode());
