This is an automated email from the ASF dual-hosted git repository.

wernerdv pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git


The following commit(s) were added to refs/heads/master by this push:
     new faacc67c240 IGNITE-29072 Fix tests using Thread.suspend() for JDK 21 
(#13619)
faacc67c240 is described below

commit faacc67c2405a2101859af7c21874537771208be
Author: Aleksandr Nikolaev <[email protected]>
AuthorDate: Thu Oct 1 13:58:09 2026 +0300

    IGNITE-29072 Fix tests using Thread.suspend() for JDK 21 (#13619)
---
 ...ClientConnectAfterCommunicationFailureTest.java | 68 ++++++++--------
 .../tcp/TcpClientDiscoverySpiSelfTest.java         | 51 ++++++++----
 .../tcp/TcpDiscoveryNetworkIssuesTest.java         | 48 ++++--------
 .../spi/discovery/tcp/TestTcpDiscoverySpi.java     | 90 ++++++++++++++++++++++
 4 files changed, 180 insertions(+), 77 deletions(-)

diff --git 
a/modules/core/src/test/java/org/apache/ignite/internal/IgniteClientConnectAfterCommunicationFailureTest.java
 
b/modules/core/src/test/java/org/apache/ignite/internal/IgniteClientConnectAfterCommunicationFailureTest.java
index e161430d38b..6de050892f3 100644
--- 
a/modules/core/src/test/java/org/apache/ignite/internal/IgniteClientConnectAfterCommunicationFailureTest.java
+++ 
b/modules/core/src/test/java/org/apache/ignite/internal/IgniteClientConnectAfterCommunicationFailureTest.java
@@ -17,17 +17,24 @@
 
 package org.apache.ignite.internal;
 
-import java.util.Arrays;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Stream;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.cluster.ClusterNode;
 import org.apache.ignite.configuration.IgniteConfiguration;
 import org.apache.ignite.internal.util.nio.GridCommunicationClient;
-import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.spi.discovery.tcp.TestTcpDiscoverySpi;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 
+import static org.apache.ignite.events.EventType.EVT_CLIENT_NODE_DISCONNECTED;
+import static org.apache.ignite.events.EventType.EVT_CLIENT_NODE_RECONNECTED;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
+
 /**
  * Tests client to be able restore connection to cluster on subsequent 
attempts after communication problems.
  */
@@ -66,45 +73,44 @@ public class 
IgniteClientConnectAfterCommunicationFailureTest extends GridCommon
         Ignite srv2 = startGrid("server2");
         Ignite client = startClientGrid("client");
 
-        boolean blockedAnything = false;
-
-        for (Thread thread : Thread.getAllStackTraces().keySet()) {
-            if (thread.getName().contains("%client%")) {
-                thread.suspend();
-                blockedAnything = true;
-            }
-        }
+        UUID clientId = client.cluster().localNode().id();
 
-        Thread.sleep(10000);
+        CountDownLatch disconnected = new CountDownLatch(1);
+        CountDownLatch reconnected = new CountDownLatch(1);
 
-        for (Thread thread : Thread.getAllStackTraces().keySet()) {
-            if (thread.getName().contains("%client%"))
-                thread.resume();
-        }
+        client.events().localListen(evt -> {
+            if (evt.type() == EVT_CLIENT_NODE_DISCONNECTED)
+                disconnected.countDown();
+            else
+                reconnected.countDown();
 
-        for (int j = 0; j < 10; j++) {
-            boolean topOk = true;
+            return true;
+        }, EVT_CLIENT_NODE_DISCONNECTED, EVT_CLIENT_NODE_RECONNECTED);
 
-            for (Ignite node : Arrays.asList(srv1, srv2, client)) {
-                if (node.cluster().nodes().size() != 3) {
-                    U.warn(log, "Grid size is incorrect (will re-run check in 
1000 ms) " +
-                        "[name=" + node.name() + ", size=" + 
node.cluster().nodes().size() + ']');
+        long timeout = 3 * 
srv1.configuration().getClientFailureDetectionTimeout();
 
-                    topOk = false;
+        TestTcpDiscoverySpi clientSpi = 
(TestTcpDiscoverySpi)client.configuration().getDiscoverySpi();
 
-                    break;
-                }
-            }
+        clientSpi.freeze();
 
-            if (topOk)
-                return;
-            else
-                Thread.sleep(1000);
+        try {
+            assertTrue(waitForCondition(() -> 
srv1.cluster().forClients().nodes().isEmpty() &&
+                srv2.cluster().forClients().nodes().isEmpty(), timeout));
+        }
+        finally {
+            clientSpi.unfreeze();
         }
 
-        assertTrue(blockedAnything);
-        assertEquals(1, srv2.cluster().forClients().nodes().size());
+        assertTrue(disconnected.await(timeout, TimeUnit.MILLISECONDS));
+        assertTrue(reconnected.await(timeout, TimeUnit.MILLISECONDS));
+
+        assertFalse(clientId.equals(client.cluster().localNode().id()));
+
+        assertTrue(waitForCondition(() -> Stream.of(srv1, srv2, 
client).allMatch(n -> n.cluster().nodes().size() == 3),
+            timeout));
+
         assertEquals(1, srv1.cluster().forClients().nodes().size());
+        assertEquals(1, srv2.cluster().forClients().nodes().size());
     }
 
     /**
diff --git 
a/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpClientDiscoverySpiSelfTest.java
 
b/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpClientDiscoverySpiSelfTest.java
index 0d5222fca2d..aac9462b628 100644
--- 
a/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpClientDiscoverySpiSelfTest.java
+++ 
b/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpClientDiscoverySpiSelfTest.java
@@ -63,7 +63,6 @@ import 
org.apache.ignite.plugin.segmentation.SegmentationPolicy;
 import org.apache.ignite.resources.IgniteInstanceResource;
 import org.apache.ignite.spi.IgniteSpiException;
 import org.apache.ignite.spi.IgniteSpiOperationTimeoutHelper;
-import org.apache.ignite.spi.IgniteSpiThread;
 import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi;
 import org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
@@ -739,6 +738,8 @@ public class TcpClientDiscoverySpiSelfTest extends 
GridCommonAbstractTest {
         clientIpFinder.setAddresses(
             Collections.singleton("localhost:" + srv2Node.discoveryPort()));
 
+        assertNull(client.cluster().node(srv2Node.id()));
+
         clientSpi.resumeAll();
 
         awaitPartitionMapExchange();
@@ -2486,6 +2487,9 @@ public class TcpClientDiscoverySpiSelfTest extends 
GridCommonAbstractTest {
         /** */
         private final AtomicBoolean openSockLock = new AtomicBoolean();
 
+        /** */
+        private final AtomicBoolean readLock = new AtomicBoolean();
+
         /** */
         private AtomicInteger failNodeAdded = new AtomicInteger();
 
@@ -2662,25 +2666,20 @@ public class TcpClientDiscoverySpiSelfTest extends 
GridCommonAbstractTest {
         }
 
         /**
-         * @param suspend If {@code true} suspends worker threads.
+         * @param pauseRead If {@code true} also pauses socket reads, which 
emulates hanging worker threads.
          */
-        public void pauseAll(boolean suspend) {
-            pauseResumeOperation(true, openSockLock, writeLock);
-
-            if (suspend) {
-                for (Thread t : impl.threads())
-                    t.suspend();
-            }
+        public void pauseAll(boolean pauseRead) {
+            if (pauseRead)
+                pauseResumeOperation(true, openSockLock, writeLock, readLock);
+            else
+                pauseResumeOperation(true, openSockLock, writeLock);
         }
 
         /**
          *
          */
         public void resumeAll() {
-            pauseResumeOperation(false, openSockLock, writeLock);
-
-            for (IgniteSpiThread t : impl.threads())
-                t.resume();
+            pauseResumeOperation(false, openSockLock, writeLock, readLock);
         }
 
         /** {@inheritDoc} */
@@ -2688,7 +2687,20 @@ public class TcpClientDiscoverySpiSelfTest extends 
GridCommonAbstractTest {
             TcpDiscoveryIoSession ses,
             long timeout
         ) throws IOException, IgniteCheckedException {
-            return msgTracker.track(ses, super.readMessage(ses, timeout));
+            waitFor(readLock);
+
+            T msg;
+
+            try {
+                msg = super.readMessage(ses, timeout);
+            }
+            finally {
+                // A reader may have been blocked on the socket before the 
pause, so hold the result (a message or
+                // a failure) until resume.
+                waitFor(readLock);
+            }
+
+            return msgTracker.track(ses, msg);
         }
 
         /** {@inheritDoc} */
@@ -2723,7 +2735,16 @@ public class TcpClientDiscoverySpiSelfTest extends 
GridCommonAbstractTest {
 
         /** {@inheritDoc} */
         @Override protected int readReceipt(TcpDiscoveryIoSession ses, long 
timeout) throws IOException {
-            int res = super.readReceipt(ses, timeout);
+            waitFor(readLock);
+
+            int res;
+
+            try {
+                res = super.readReceipt(ses, timeout);
+            }
+            finally {
+                waitFor(readLock);
+            }
 
             if (res != TcpDiscoveryImpl.RES_OK) {
                 invalidRes = true;
diff --git 
a/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpDiscoveryNetworkIssuesTest.java
 
b/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpDiscoveryNetworkIssuesTest.java
index 43996bbd6c4..113617f4fc7 100644
--- 
a/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpDiscoveryNetworkIssuesTest.java
+++ 
b/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TcpDiscoveryNetworkIssuesTest.java
@@ -34,25 +34,20 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
-import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteLogger;
 import org.apache.ignite.cluster.ClusterNode;
 import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.events.DiscoveryEvent;
 import org.apache.ignite.internal.IgniteEx;
 import org.apache.ignite.internal.managers.GridManagerAdapter;
 import org.apache.ignite.internal.managers.discovery.GridDiscoveryManager;
 import org.apache.ignite.internal.util.GridConcurrentHashSet;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.util.typedef.G;
-import org.apache.ignite.internal.util.typedef.internal.U;
-import org.apache.ignite.internal.util.worker.GridWorker;
 import org.apache.ignite.spi.IgniteSpiOperationTimeoutHelper;
-import org.apache.ignite.spi.communication.CommunicationSpi;
-import org.apache.ignite.spi.communication.tcp.internal.GridNioServerWrapper;
-import org.apache.ignite.spi.discovery.DiscoverySpi;
 import org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode;
 import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
 import 
org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryAbstractMessage;
@@ -141,7 +136,7 @@ public class TcpDiscoveryNetworkIssuesTest extends 
GridCommonAbstractTest {
     @Override protected IgniteConfiguration getConfiguration(String 
igniteInstanceName) throws Exception {
         IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
 
-        TcpDiscoverySpi spi = (specialSpi != null) ? specialSpi : new 
TcpDiscoverySpi();
+        TcpDiscoverySpi spi = (specialSpi != null) ? specialSpi : new 
TestTcpDiscoverySpi();
 
         if (usePortFromNodeName)
             
spi.setLocalPort(Integer.parseInt(igniteInstanceName.split("-")[1]));
@@ -444,11 +439,11 @@ public class TcpDiscoveryNetworkIssuesTest extends 
GridCommonAbstractTest {
 
         awaitPartitionMapExchange();
 
-        final CountDownLatch failLatch = new CountDownLatch(2);
+        Set<UUID> failedIds = new GridConcurrentHashSet<>();
 
         for (int i = 0; i < gridCnt; i++) {
             ignite(i).events().localListen(evt -> {
-                failLatch.countDown();
+                failedIds.add(((DiscoveryEvent)evt).eventNode().id());
 
                 return true;
             }, EVT_NODE_FAILED);
@@ -471,15 +466,25 @@ public class TcpDiscoveryNetworkIssuesTest extends 
GridCommonAbstractTest {
         else
             failedNodes.add(4);
 
-        failedNodes.forEach(idx -> processNetworkThreads(ignite(idx), 
Thread::suspend));
+        Set<UUID> frozenIds = 
failedNodes.stream().map(this::nodeId).collect(Collectors.toSet());
+
+        Set<UUID> healthyIds = G.allGrids().stream().map(ig -> 
ig.cluster().localNode().id())
+            .filter(id -> !frozenIds.contains(id)).collect(Collectors.toSet());
+
+        failedNodes.forEach(idx -> 
((TestTcpDiscoverySpi)spi(ignite(idx))).freeze());
 
         try {
-            failLatch.await(10, TimeUnit.SECONDS);
+            assertTrue(waitForCondition(() -> failedIds.containsAll(frozenIds) 
&& G.allGrids().stream()
+                .filter(ig -> 
healthyIds.contains(ig.cluster().localNode().id()))
+                .allMatch(ig -> 
healthyIds.equals(ig.cluster().nodes().stream().map(ClusterNode::id)
+                    .collect(Collectors.toSet()))), 10_000));
         }
         finally {
-            failedNodes.forEach(idx -> processNetworkThreads(ignite(idx), 
Thread::resume));
+            failedNodes.forEach(idx -> 
((TestTcpDiscoverySpi)spi(ignite(idx))).unfreeze());
         }
 
+        assertEquals(frozenIds, failedIds);
+
         for (int i = 0; i < gridCnt; i++) {
             if (!failedNodes.contains(i))
                 assertFalse(segmentedNodes.contains(i));
@@ -547,25 +552,6 @@ public class TcpDiscoveryNetworkIssuesTest extends 
GridCommonAbstractTest {
         ses.socket().getOutputStream().close();
     }
 
-    /**
-     * Simulates network failure on certain node.
-     */
-    private void processNetworkThreads(Ignite ignite, Consumer<Thread> proc) {
-        DiscoverySpi disco = ignite.configuration().getDiscoverySpi();
-
-        ServerImpl serverImpl = U.field(disco, "impl");
-
-        for (Thread thread : serverImpl.threads())
-            proc.accept(thread);
-
-        CommunicationSpi<?> comm = 
ignite.configuration().getCommunicationSpi();
-
-        GridNioServerWrapper nioServerWrapper = U.field(comm, "nioSrvWrapper");
-
-        for (GridWorker worker : nioServerWrapper.nio().workers())
-            proc.accept(worker.runner());
-    }
-
     /** */
     private static TestDiscoverySpi testSpi(Ignite ig) {
         return ((TestDiscoverySpi)ig.configuration().getDiscoverySpi());
diff --git 
a/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TestTcpDiscoverySpi.java
 
b/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TestTcpDiscoverySpi.java
index feedf6a4c6e..57d65baf786 100644
--- 
a/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TestTcpDiscoverySpi.java
+++ 
b/modules/core/src/test/java/org/apache/ignite/spi/discovery/tcp/TestTcpDiscoverySpi.java
@@ -21,14 +21,17 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InterruptedIOException;
 import java.io.OutputStream;
 import java.net.Socket;
 import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
 import org.apache.ignite.internal.GridKernalContext;
 import 
org.apache.ignite.internal.managers.discovery.IgniteDiscoverySpiInternalListener;
 import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.plugin.extensions.communication.Message;
 import org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage;
 import org.apache.ignite.spi.discovery.DiscoverySpiListener;
 import 
org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryAbstractMessage;
@@ -53,9 +56,75 @@ public class TestTcpDiscoverySpi extends TcpDiscoverySpi 
implements IgniteDiscov
     /** */
     private IgniteDiscoverySpiInternalListener internalLsnr;
 
+    /** Latch released on {@link #unfreeze()}, {@code null} if the discovery 
I/O is not frozen. */
+    private volatile CountDownLatch freezeLatch;
+
+    /**
+     * Freezes the discovery I/O of this node: every socket read and write 
blocks until {@link #unfreeze()} is called.
+     * The node keeps accepting TCP connections. Emulates a node whose threads 
hang, e.g. at a long GC pause.
+     */
+    public synchronized void freeze() {
+        if (freezeLatch == null)
+            freezeLatch = new CountDownLatch(1);
+    }
+
+    /** Releases the discovery I/O frozen by {@link #freeze()}. */
+    public synchronized void unfreeze() {
+        if (freezeLatch != null) {
+            freezeLatch.countDown();
+
+            freezeLatch = null;
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void write(TcpDiscoveryIoSession ses, byte[] data, 
long timeout) throws IOException, IgniteCheckedException {
+        awaitUnfrozen();
+
+        super.write(ses, data, timeout);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void writeReceipt(TcpDiscoveryIoSession ses, int res, 
long timeout) throws IOException, IgniteCheckedException {
+        awaitUnfrozen();
+
+        super.writeReceipt(ses, res, timeout);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected <T extends Message> T readMessage(
+        TcpDiscoveryIoSession ses,
+        long timeout
+    ) throws IOException, IgniteCheckedException {
+        awaitUnfrozen();
+
+        try {
+            return super.readMessage(ses, timeout);
+        }
+        finally {
+            // A reader may have been blocked on the socket before the freeze, 
so hold the result (a message or
+            // a failure) until unfreeze.
+            awaitUnfrozen();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override protected int readReceipt(TcpDiscoveryIoSession ses, long 
timeout) throws IOException {
+        awaitUnfrozen();
+
+        try {
+            return super.readReceipt(ses, timeout);
+        }
+        finally {
+            awaitUnfrozen();
+        }
+    }
+
     /** {@inheritDoc} */
     @Override protected void writeMessage(TcpDiscoveryIoSession ses, 
TcpDiscoveryAbstractMessage msg, long timeout) throws IOException,
         IgniteCheckedException {
+        awaitUnfrozen();
+
         if (msg instanceof TcpDiscoveryPingResponse && ignorePingResponse)
             return;
 
@@ -131,4 +200,25 @@ public class TestTcpDiscoverySpi extends TcpDiscoverySpi 
implements IgniteDiscov
             throw new IgniteException("Failed to decode a message", e);
         }
     }
+
+    /**
+     * Blocks while the discovery I/O is frozen.
+     *
+     * @throws InterruptedIOException If interrupted.
+     */
+    private void awaitUnfrozen() throws InterruptedIOException {
+        CountDownLatch latch = freezeLatch;
+
+        if (latch == null)
+            return;
+
+        try {
+            latch.await();
+        }
+        catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+
+            throw new InterruptedIOException("Interrupted while discovery I/O 
is frozen.");
+        }
+    }
 }

Reply via email to