Address review comment: wrap ETE to make it recognisable by ExceptionsHelper.isRemoteUnavailableException()

Author: pawankartik-elastic

server/src/internalClusterTest/java/org/elasticsearch/indices/cluster/RemoteFieldCapsForceConnectTimeoutIT.java

@@ -9,6 +9,7 @@
 
 package org.elasticsearch.indices.cluster;
 
+import org.elasticsearch.ElasticsearchTimeoutException;
 import org.elasticsearch.action.fieldcaps.FieldCapabilitiesRequest;
 import org.elasticsearch.action.fieldcaps.TransportFieldCapabilitiesAction;
 import org.elasticsearch.common.settings.Setting;
@@ -119,11 +120,15 @@ public void testTimeoutSetting() {
             var failure = failures.getFirst();
             assertThat(failure.getIndices().length, Matchers.is(1));
             assertThat(failure.getIndices()[0], Matchers.equalTo("cluster-a:*"));
+            // Outer wrapper that gets unwrapped in ExceptionsHelper.isRemoteUnavailableException().
             assertThat(
                 failure.getException().toString(),
-                Matchers.containsString("org.elasticsearch.ElasticsearchTimeoutException: timed out after [1s/1000ms]")
+                Matchers.containsString("java.lang.IllegalStateException: Unable to open any connections")
             );
 
+            // The actual error that is thrown by the subscribable listener when a remote could not be talked to.
+            assertThat(failure.getException().getCause(), Matchers.instanceOf(ElasticsearchTimeoutException.class));
+
             latch.countDown();
             result.decRef();
         }

server/src/main/java/org/elasticsearch/action/fieldcaps/TransportFieldCapabilitiesAction.java

@@ -405,7 +405,11 @@ private static void mergeIndexResponses(
                  * Under no circumstances are we to pass timeout errors originating from SubscribableListener as top-level errors.
                  * Instead, they should always be passed through the response object, as part of "failures".
                  */
-                if (failures.stream().anyMatch(failure -> failure.getException() instanceof ElasticsearchTimeoutException)) {
+                if (failures.stream()
+                    .anyMatch(
+                        failure -> failure.getException() instanceof IllegalStateException ise
+                            && ise.getCause() instanceof ElasticsearchTimeoutException
+                    )) {
                     listener.onResponse(new FieldCapabilitiesResponse(Collections.emptyList(), failures));
                 } else {
                     // throw back the first exception
@@ -618,15 +622,24 @@ List<FieldCapabilitiesFailure> build(Set<String> successfulIndices) {
             for (Map.Entry<String, Exception> failure : failuresByIndex.entrySet()) {
                 String index = failure.getKey();
                 Exception e = failure.getValue();
+                /*
+                 * The listener we use to briefly try, and connect to a remote can throw an ElasticsearchTimeoutException
+                 * error if a remote cannot be reached. To make sure we correctly recognise this scenario via
+                 * ExceptionsHelper.isRemoteUnavailableException(), we wrap this error appropriately.
+                 */
+                if (e instanceof ElasticsearchTimeoutException ete) {
+                    e = new IllegalStateException("Unable to open any connections", ete);
+                }
 
                 if (successfulIndices.contains(index) == false) {
                     // we deduplicate exceptions on the underlying causes message and classname
                     // we unwrap the cause to e.g. group RemoteTransportExceptions coming from different nodes if the cause is the same
                     Throwable cause = ExceptionsHelper.unwrapCause(e);
                     Tuple<String, String> groupingKey = new Tuple<>(cause.getMessage(), cause.getClass().getName());
+                    Exception ex = e;
                     indexFailures.compute(
                         groupingKey,
-                        (k, v) -> v == null ? new FieldCapabilitiesFailure(new String[] { index }, e) : v.addIndex(index)
+                        (k, v) -> v == null ? new FieldCapabilitiesFailure(new String[] { index }, ex) : v.addIndex(index)
                     );
                 }
             }