IGNITE-27285 Make common approach to Lock exceptions with the same message (#7271)

Author: JAkutenshi

modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/exception/OperationLockException.java

@@ -36,7 +36,7 @@ public class OperationLockException extends LockException {
     public OperationLockException(RequestType requestOperationType, LockException cause) {
         super(
                 cause.code(),
-                format("Lock acquiring failed during request handling [requestOperationType={}].", requestOperationType),
+                format("Failed to acquire a lock during request handling [requestOperationType={}].", requestOperationType),
                 cause
         );
     }

modules/platforms/cpp/tests/odbc-test/transaction_test.cpp

@@ -591,7 +591,7 @@ TEST_F(transaction_test, transaction_error) {
             try {
                 insert_test_value(conn2.m_statement, 2, "test_2");
             } catch (const odbc_exception &err) {
-                EXPECT_THAT(err.message, testing::HasSubstr("Lock acquiring failed during request handling"));
+                EXPECT_THAT(err.message, testing::HasSubstr("Failed to acquire a lock during request handling"));
                 EXPECT_EQ(err.sql_state, "25000");
                 throw;
             }

modules/runner/src/integrationTest/java/org/apache/ignite/internal/table/ItTableScanTest.java

@@ -1083,7 +1083,7 @@ private static void assertPossibleDeadLockExceptionOnReadWriteSingleRowOperation
                 TransactionException.class,
                 Transactions.ACQUIRE_LOCK_ERR,
                 operation,
-                "Lock acquiring failed during request handling"
+                "Failed to acquire a lock during request handling"
         );
 
         Throwable rootCause = unwrapRootCause(transactionException);

modules/table/src/testFixtures/java/org/apache/ignite/internal/table/TxAbstractTest.java

@@ -2382,7 +2382,7 @@ protected void testTransactionAlreadyFinished(
 
     private static void assertTransactionLockException(Exception e) {
         assertInstanceOf(TransactionException.class, e);
-        assertThat(e.getMessage(), containsString("Lock acquiring failed during request handling"));
+        assertThat(e.getMessage(), containsString("Failed to acquire a lock during request handling"));
 
         Throwable rootCause = unwrapRootCause(e);
         assertInstanceOf(LockException.class, rootCause);

modules/transactions/src/main/java/org/apache/ignite/internal/tx/AcquireLockTimeoutException.java

@@ -0,0 +1,41 @@
+/*
+ * 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.lang.ErrorGroups.Transactions.ACQUIRE_LOCK_TIMEOUT_ERR;
+
+/**
+ * This exception is thrown when a lock cannot be acquired in a timeout boundaries.
+ */
+public class AcquireLockTimeoutException extends LockException {
+    /**
+     * Constructor.
+     *
+     * @param waiter Waiter for lock acquisition.
+     * @param exceededTimeout Exceeded timeout value in milliseconds.
+     */
+    public AcquireLockTimeoutException(Waiter waiter, long exceededTimeout) {
+        super(
+                ACQUIRE_LOCK_TIMEOUT_ERR,
+                "Failed to acquire a lock due to timeout [txId=" + waiter.txId()
+                        + ", waiter=" + waiter
+                        + ", timeoutMs=" + exceededTimeout
+                        + ']'
+        );
+    }
+}

modules/transactions/src/main/java/org/apache/ignite/internal/tx/LockTableOverflowException.java

@@ -0,0 +1,41 @@
+/*
+ * 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.lang.ErrorGroups.Transactions.ACQUIRE_LOCK_ERR;
+
+import java.util.UUID;
+
+/**
+ * This exception is thrown when the lock map size exceeded and new lock cannot be acquired and placed there.
+ */
+public class LockTableOverflowException extends LockException {
+    /**
+     * Constructor.
+     *
+     * @param failedTx Transaction that couldn't acquire a lock.
+     * @param lockMapSizeLimit Current lock map size limit that was exceeded.
+     */
+    public LockTableOverflowException(UUID failedTx, int lockMapSizeLimit) {
+        super(
+                ACQUIRE_LOCK_ERR,
+                "Failed to acquire a lock due to lock table overflow [failedTxId=" + failedTx
+                        + ", lockMapSizeLimit=" + lockMapSizeLimit + ']'
+        );
+    }
+}

modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java

@@ -23,7 +23,6 @@
 import static org.apache.ignite.internal.tx.event.LockEvent.LOCK_CONFLICT;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.lang.ErrorGroups.Transactions.ACQUIRE_LOCK_ERR;
-import static org.apache.ignite.lang.ErrorGroups.Transactions.ACQUIRE_LOCK_TIMEOUT_ERR;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -51,12 +50,14 @@
 import org.apache.ignite.internal.lang.IgniteBiTuple;
 import org.apache.ignite.internal.tostring.IgniteToStringExclude;
 import org.apache.ignite.internal.tostring.S;
+import org.apache.ignite.internal.tx.AcquireLockTimeoutException;
 import org.apache.ignite.internal.tx.DeadlockPreventionPolicy;
 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.LockTableOverflowException;
 import org.apache.ignite.internal.tx.PossibleDeadlockOnLockAcquireException;
 import org.apache.ignite.internal.tx.Waiter;
 import org.apache.ignite.internal.tx.event.LockEvent;
@@ -165,10 +166,7 @@ public CompletableFuture<Lock> acquire(UUID txId, LockKey lockKey, LockMode lock
             LockState state = acquireLockState(lockKey);
 
             if (state == null) {
-                return failedFuture(new LockException(
-                        ACQUIRE_LOCK_ERR,
-                        "Failed to acquire a lock due to lock table overflow [txId=" + txId + ", limit=" + lockMapSize + ']'
-                ));
+                return failedFuture(new LockTableOverflowException(txId, lockMapSize));
             }
 
             IgniteBiTuple<CompletableFuture<Void>, LockMode> futureTuple = state.tryAcquire(txId, lockMode);
@@ -900,7 +898,8 @@ private boolean isWaiterReadyToNotify(WaiterImpl waiter, boolean skipFail) {
                     } else if (deadlockPreventionPolicy.waitTimeout() == 0) {
                         waiter.fail(new PossibleDeadlockOnLockAcquireException(
                                 waiter.txId,
-                                tmp.txId, intendedLockMode,
+                                tmp.txId,
+                                intendedLockMode,
                                 currentlyAcquiredLockMode
                         ));
 
@@ -1047,9 +1046,7 @@ private List<WaiterImpl> unlockCompatibleWaiters() {
         private void setWaiterTimeout(WaiterImpl waiter) {
             delayedExecutor.execute(() -> {
                 if (!waiter.fut.isDone()) {
-                    waiter.fut.completeExceptionally(new LockException(ACQUIRE_LOCK_TIMEOUT_ERR, "Failed to acquire a lock due to "
-                            + "timeout [txId=" + waiter.txId() + ", waiter=" + waiter
-                            + ", timeout=" + deadlockPreventionPolicy.waitTimeout() + ']'));
+                    waiter.fut.completeExceptionally(new AcquireLockTimeoutException(waiter, deadlockPreventionPolicy.waitTimeout()));
                 }
             });
         }

modules/transactions/src/test/java/org/apache/ignite/internal/tx/HeapLockManagerTest.java

@@ -71,7 +71,7 @@ public void testLockTableOverflow() throws Exception {
         CompletableFuture<Lock> overflowLockFut = lockManager.acquire(overflowTx, new LockKey(overflowTx, overflowTx), LockMode.S);
 
         assertThat(overflowLockFut, willThrowWithCauseOrSuppressed(
-                LockException.class,
+                LockTableOverflowException.class,
                 "Failed to acquire a lock due to lock table overflow"
         ));
 
@@ -107,7 +107,7 @@ public void testLockTooManyKeysInTx() throws Exception {
             CompletableFuture<Lock> overflowLockFut = lockManager.acquire(txId, new LockKey(i, i), LockMode.S);
 
             assertThat(overflowLockFut, willThrowWithCauseOrSuppressed(
-                    LockException.class,
+                    LockTableOverflowException.class,
                     "Failed to acquire a lock due to lock table overflow"
             ));
         }