[CI] Auto commit changes from spotless

Author: elasticsearchmachine

server/src/internalClusterTest/java/org/elasticsearch/cluster/coordination/MasterElectionTestCase.java

@@ -77,7 +77,11 @@ protected CountDownLatch configureElectionLatchForNewMaster(String newMaster, Li
      * @param cleanupTasks The list of cleanup tasks
      * @return A latch that will be released when the master acknowledges it's re-election
      */
-    protected CountDownLatch configureElectionLatchForReElectedMaster(String masterNodeName, long originalTerm, List<Releasable> cleanupTasks) {
+    protected CountDownLatch configureElectionLatchForReElectedMaster(
+        String masterNodeName,
+        long originalTerm,
+        List<Releasable> cleanupTasks
+    ) {
         final var masterKnowsItIsReElectedLatch = new CountDownLatch(1);
         ClusterStateApplier newMasterMonitor = event -> {
             DiscoveryNode masterNode = event.state().nodes().getMasterNode();

server/src/internalClusterTest/java/org/elasticsearch/cluster/coordination/NodeJoiningIT.java

@@ -41,10 +41,7 @@ public class NodeJoiningIT extends MasterElectionTestCase {
 
     @Override
     protected Collection<Class<? extends Plugin>> nodePlugins() {
-        return CollectionUtils.appendToCopyNoNullElements(
-            super.nodePlugins(),
-            MockTransportService.TestPlugin.class
-        );
+        return CollectionUtils.appendToCopyNoNullElements(super.nodePlugins(), MockTransportService.TestPlugin.class);
     }
 
     @Override
@@ -123,11 +120,10 @@ public void testNodeTriesToJoinClusterAndThenDifferentMasterIsElected() {
                 if (mockTransportService.getLocalNode().getName().equals(newMasterNodeName) == false) {
                     mockTransportService.addSendBehavior((connection, requestId, action, request, options) -> {
                         if (
-                            // This disables pre-voting on all nodes except the new master, forcing it to win the election
-                            action.equals(StatefulPreVoteCollector.REQUEST_PRE_VOTE_ACTION_NAME)
+                        // This disables pre-voting on all nodes except the new master, forcing it to win the election
+                        action.equals(StatefulPreVoteCollector.REQUEST_PRE_VOTE_ACTION_NAME)
                             // This forces the current master node to fail
-                            || action.equals(PublicationTransportHandler.PUBLISH_STATE_ACTION_NAME)
-                        ) {
+                            || action.equals(PublicationTransportHandler.PUBLISH_STATE_ACTION_NAME)) {
                             throw new ElasticsearchException("[{}] for [{}] denied", action, connection.getNode());
                         } else {
                             connection.sendRequest(requestId, action, request, options);
@@ -179,8 +175,8 @@ public void testNodeTriesToJoinClusterAndThenDifferentMasterIsElected() {
 
     // Tests whether a WARN log is thrown when a node attempts to join a cluster, and then the same master node is re-elected (#126192)
     @TestLogging(
-            reason = "test includes assertions about logging",
-            value = "org.elasticsearch.cluster.coordination.NodeJoinExecutor:WARN,org.elasticsearch.cluster.coordination.NodeJoinExecutor:INFO,org.elasticsearch.cluster.coordination.MasterService:WARN,org.elasticsearch.cluster.coordination.MasterService:INFO,org.elasticsearch.cluster.coordination.ClusterApplierService:WARN"
+        reason = "test includes assertions about logging",
+        value = "org.elasticsearch.cluster.coordination.NodeJoinExecutor:WARN,org.elasticsearch.cluster.coordination.NodeJoinExecutor:INFO,org.elasticsearch.cluster.coordination.MasterService:WARN,org.elasticsearch.cluster.coordination.MasterService:INFO,org.elasticsearch.cluster.coordination.ClusterApplierService:WARN"
     )
     public void testNodeTriesToJoinClusterAndThenSameMasterIsElected_DoesNotIncludeWarnLog() {
         final var cleanupTasks = new ArrayList<Releasable>();
@@ -210,10 +206,18 @@ public void testNodeTriesToJoinClusterAndThenSameMasterIsElected_DoesNotIncludeW
             });
 
             // Latch to remove publishing ban to allow re-election
-            CountDownLatch publishingBanRemovedLatch = removeMockTransportServicePublishBanWhenMasterHasSteppedDown(masterNodeName, masterNodeTransportService, cleanupTasks);
+            CountDownLatch publishingBanRemovedLatch = removeMockTransportServicePublishBanWhenMasterHasSteppedDown(
+                masterNodeName,
+                masterNodeTransportService,
+                cleanupTasks
+            );
 
             // A CountDownLatch that only gets decremented when the first master node is re-elected
-            final var masterKnowsItHasBeenReElectedLatch = configureElectionLatchForReElectedMaster(masterNodeName, originalTerm, cleanupTasks);
+            final var masterKnowsItHasBeenReElectedLatch = configureElectionLatchForReElectedMaster(
+                masterNodeName,
+                originalTerm,
+                cleanupTasks
+            );
 
             for (String nodeName : internalCluster().getNodeNames()) {
                 final var mockTransportService = MockTransportService.getInstance(nodeName);
@@ -280,9 +284,9 @@ public void testNodeTriesToJoinClusterAndThenSameMasterIsElected_DoesNotIncludeW
                     // Await for N to be in the cluster state of all nodes
                     for (String nodeName : namesOfAllNodesInOriginalCluster) {
                         ClusterServiceUtils.awaitClusterState(
-                                logger,
-                                clusterState -> clusterState.nodes().nodeExistsWithName(newNodeName),
-                                internalCluster().clusterService(nodeName)
+                            logger,
+                            clusterState -> clusterState.nodes().nodeExistsWithName(newNodeName),
+                            internalCluster().clusterService(nodeName)
                         );
                     }
                 } catch (Exception e) {
@@ -309,10 +313,8 @@ public void testNodeTriesToJoinClusterAndThenSameMasterIsElected_DoesNotIncludeW
         }
     }
 
-
-    private List<String> getListOfDataNodeNamesFromCluster(String nodeName){
-        return internalCluster()
-            .clusterService(nodeName)
+    private List<String> getListOfDataNodeNamesFromCluster(String nodeName) {
+        return internalCluster().clusterService(nodeName)
             .state()
             .getNodes()
             .getDataNodes()
@@ -336,12 +338,7 @@ public void match(LogEvent event) {
                     return;
                 }
 
-                Pattern pattern = Pattern.compile(
-                        "node-join: \\["
-                                + expectedNewNodeAsString
-                                + "] "
-                                + "with reason \\[joining]"
-                );
+                Pattern pattern = Pattern.compile("node-join: \\[" + expectedNewNodeAsString + "] " + "with reason \\[joining]");
                 Matcher matcher = pattern.matcher(event.getMessage().getFormattedMessage());
 
                 if (matcher.find()) {
@@ -370,11 +367,15 @@ public void match(LogEvent event) {
                 }
 
                 Pattern pattern = Pattern.compile(
-                        "node-join\\["
+                    "node-join\\["
                         + expectedNewNodeAsString
                         + " joining],"
-                        + " term: " + term + ","
-                        + " version: " + version + ","
+                        + " term: "
+                        + term
+                        + ","
+                        + " version: "
+                        + version
+                        + ","
                         + " delta: added \\{"
                         + expectedNewNodeAsString
                         + "}"
@@ -407,9 +408,11 @@ public void match(LogEvent event) {
                 }
 
                 Pattern pattern = Pattern.compile(
-                        "failing \\[node-join\\["
-                                + expectedNewNodeAsString
-                                + " joining]]: failed to commit cluster state version \\[" + version +"]"
+                    "failing \\[node-join\\["
+                        + expectedNewNodeAsString
+                        + " joining]]: failed to commit cluster state version \\["
+                        + version
+                        + "]"
                 );
                 Matcher matcher = pattern.matcher(event.getMessage().getFormattedMessage());
 
@@ -440,13 +443,13 @@ public void match(LogEvent event) {
 
                 String regexToMatchAnyCharacterExceptClosingBrace = "([^}]+)";
                 Pattern pattern = Pattern.compile(
-                        "node-join: \\["
-                                + expectedNewNodeAsString
-                                + "] "
-                                + "with reason \\[joining, removed \\["
-                                + regexToMatchAnyCharacterExceptClosingBrace
-                                + "] ago with reason \\[disconnected]]; "
-                                + "for troubleshooting guidance, see https://www.elastic.co/docs/troubleshoot/elasticsearch/troubleshooting-unstable-cluster\\?version=master"
+                    "node-join: \\["
+                        + expectedNewNodeAsString
+                        + "] "
+                        + "with reason \\[joining, removed \\["
+                        + regexToMatchAnyCharacterExceptClosingBrace
+                        + "] ago with reason \\[disconnected]]; "
+                        + "for troubleshooting guidance, see https://www.elastic.co/docs/troubleshoot/elasticsearch/troubleshooting-unstable-cluster\\?version=master"
                 );
                 Matcher matcher = pattern.matcher(event.getMessage().getFormattedMessage());
 
@@ -462,7 +465,10 @@ public void assertMatched() {
         });
     }
 
-    private void addNodeJoinProcessedDuringNewElectionAndClusterStatePublicationExpectation(MockLog mockLog, String expectedNewNodeAsString) {
+    private void addNodeJoinProcessedDuringNewElectionAndClusterStatePublicationExpectation(
+        MockLog mockLog,
+        String expectedNewNodeAsString
+    ) {
         mockLog.addExpectation(new MockLog.LoggingExpectation() {
             boolean matched = false;
 
@@ -475,11 +481,7 @@ public void match(LogEvent event) {
                     return;
                 }
 
-                Pattern pattern = Pattern.compile(
-                        "added \\{"
-                        + expectedNewNodeAsString
-                        + "}"
-                );
+                Pattern pattern = Pattern.compile("added \\{" + expectedNewNodeAsString + "}");
                 Matcher matcher = pattern.matcher(event.getMessage().getFormattedMessage());
 
                 if (matcher.find()) {
@@ -500,15 +502,31 @@ private String generateNodeDescriptionForNewDiscoveryNode(int numberOfNodesOrigi
         String newNodeName = "node_s" + numberOfNodesOriginallyInCluster;
         String regexToMatchAnyCharacterExceptClosingBrace = "([^}]+)";
 
-        return "\\{" + newNodeName + "}"
-            + "\\{" + regexToMatchAnyCharacterExceptClosingBrace + "}"
-            + "\\{" + regexToMatchAnyCharacterExceptClosingBrace + "}"
-            + "\\{" + newNodeName + "}"
-            + "\\{" + masterNode.getHostAddress() + "}"
-            + "\\{" + masterNode.getHostAddress() + ":\\d+}"
+        return "\\{"
+            + newNodeName
+            + "}"
+            + "\\{"
+            + regexToMatchAnyCharacterExceptClosingBrace
+            + "}"
+            + "\\{"
+            + regexToMatchAnyCharacterExceptClosingBrace
+            + "}"
+            + "\\{"
+            + newNodeName
+            + "}"
+            + "\\{"
+            + masterNode.getHostAddress()
+            + "}"
+            + "\\{"
+            + masterNode.getHostAddress()
+            + ":\\d+}"
             + "\\{d}"
-            + "\\{" + masterNode.getVersion() + "}"
-            + "\\{" + regexToMatchAnyCharacterExceptClosingBrace + "}";
+            + "\\{"
+            + masterNode.getVersion()
+            + "}"
+            + "\\{"
+            + regexToMatchAnyCharacterExceptClosingBrace
+            + "}";
     }
 
     /**
@@ -518,7 +536,11 @@ private String generateNodeDescriptionForNewDiscoveryNode(int numberOfNodesOrigi
      * @param mockTransportService The transport service to remove the `addSendBehavior` from
      * @param cleanupTasks The list of cleanup tasks
      */
-    protected CountDownLatch removeMockTransportServicePublishBanWhenMasterHasSteppedDown(String masterNodeName, MockTransportService mockTransportService, List<Releasable> cleanupTasks) {
+    protected CountDownLatch removeMockTransportServicePublishBanWhenMasterHasSteppedDown(
+        String masterNodeName,
+        MockTransportService mockTransportService,
+        List<Releasable> cleanupTasks
+    ) {
         CountDownLatch latch = new CountDownLatch(1);
         ClusterStateApplier newMasterMonitor = event -> {
             DiscoveryNode masterNode = event.state().nodes().getMasterNode();

server/src/main/java/org/elasticsearch/cluster/coordination/Coordinator.java

@@ -669,48 +669,48 @@ private void handleJoinRequest(JoinRequest joinRequest, ActionListener<Void> joi
         transportService.connectToNode(joinRequest.getSourceNode(), new ActionListener<>() {
             @Override
             public void onResponse(Releasable response) {
-                validateJoinRequest(
-                    joinRequest,
-                    ActionListener
-                        .runBefore(
-                            joinListener,
-                            () -> {
-                                /*
-                                    This prevents a corner case, explained in #ES-11449, occurring as follows:
-                                    - Master M is in term T and has cluster state (T, V).
-                                    - Node N tries to join the cluster.
-                                    - M proposes cluster state (T, V+1) with N in the cluster.
-                                    - M accepts its own proposal and commits it to disk.
-                                    - M receives no responses. M doesn't know whether the state was accepted by a majority of nodes, rejected, or did not reach any nodes.
-                                    - There is a re-election and M wins. M publishes cluster state (T+1, V+2).
-                                      Since it's built from the cluster state on disk, N is still in the cluster.
-                                    - Since (T, V+1) failed, N's connection is dropped, even though its inclusion in the cluster may have been committed on a majority of master nodes.
-                                    - It can rejoin, but this throws a WARN log since it did not restart.
-
-                                    To mitigate this, we listen for any cluster state update:
-                                    1. (T, V+1) is accepted -> NodeConnectionsService now stores an open connection to N. It can be closed.
-                                    2. (T, V+1) is rejected -> A new cluster state is published without N in it. It is right to close the connection and retry.
-                                    3. The above scenario occurs. We do not close the connection after (T, V+1) fails and keep it open:
-                                        3.1 (T+1, V+2) is accepted -> By waiting, we did not close the connection to N unnecessarily
-                                        3.2 (T+1, V+2) is rejected -> A new cluster state is published without N in it. Closing is correct here.
-                                 */
-                                logger.info("inside callback, node is is {}, source node is {}", clusterService.state().nodes().getLocalNode().getName(), joinRequest.getSourceNode().getName());
-                                ClusterStateListener listener = new ClusterStateListener() {
-                                    @Override
-                                    public void clusterChanged(ClusterChangedEvent event) {
-                                        logger.info("inside cluster change event, source node is {}, added nodes are {}", joinRequest.getSourceNode().getName(), event.nodesDelta().addedNodes());
-                                        // Now it's safe to close the connection
-                                        Releasables.close(response);
-                                        // Remove this listener to avoid memory leaks
-                                        clusterService.removeListener(this);
-                                    }
-                                };
+                validateJoinRequest(joinRequest, ActionListener.runBefore(joinListener, () -> {
+                    /*
+                        This prevents a corner case, explained in #ES-11449, occurring as follows:
+                        - Master M is in term T and has cluster state (T, V).
+                        - Node N tries to join the cluster.
+                        - M proposes cluster state (T, V+1) with N in the cluster.
+                        - M accepts its own proposal and commits it to disk.
+                        - M receives no responses. M doesn't know whether the state was accepted by a majority of nodes, rejected, or did not reach any nodes.
+                        - There is a re-election and M wins. M publishes cluster state (T+1, V+2).
+                          Since it's built from the cluster state on disk, N is still in the cluster.
+                        - Since (T, V+1) failed, N's connection is dropped, even though its inclusion in the cluster may have been committed on a majority of master nodes.
+                        - It can rejoin, but this throws a WARN log since it did not restart.
+
+                        To mitigate this, we listen for any cluster state update:
+                        1. (T, V+1) is accepted -> NodeConnectionsService now stores an open connection to N. It can be closed.
+                        2. (T, V+1) is rejected -> A new cluster state is published without N in it. It is right to close the connection and retry.
+                        3. The above scenario occurs. We do not close the connection after (T, V+1) fails and keep it open:
+                            3.1 (T+1, V+2) is accepted -> By waiting, we did not close the connection to N unnecessarily
+                            3.2 (T+1, V+2) is rejected -> A new cluster state is published without N in it. Closing is correct here.
+                     */
+                    logger.info(
+                        "inside callback, node is is {}, source node is {}",
+                        clusterService.state().nodes().getLocalNode().getName(),
+                        joinRequest.getSourceNode().getName()
+                    );
+                    ClusterStateListener listener = new ClusterStateListener() {
+                        @Override
+                        public void clusterChanged(ClusterChangedEvent event) {
+                            logger.info(
+                                "inside cluster change event, source node is {}, added nodes are {}",
+                                joinRequest.getSourceNode().getName(),
+                                event.nodesDelta().addedNodes()
+                            );
+                            // Now it's safe to close the connection
+                            Releasables.close(response);
+                            // Remove this listener to avoid memory leaks
+                            clusterService.removeListener(this);
+                        }
+                    };
 
-                                clusterService.addListener(listener);
-                            }
-                        )
-                        .delegateFailure((l, ignored) -> processJoinRequest(joinRequest, l))
-                );
+                    clusterService.addListener(listener);
+                }).delegateFailure((l, ignored) -> processJoinRequest(joinRequest, l)));
             }
 
             @Override