Fix comments, typos and names

Author: ywangd

server/src/main/java/org/elasticsearch/health/node/ShardsCapacityHealthIndicatorService.java

@@ -141,8 +141,8 @@ private HealthIndicatorResult mergeIndicators(boolean verbose, List<StatusResult
             final var nodeTypeNames = new ArrayList<String>();
             for (var statusResult : statusResults) {
                 if (statusResult.status.indicatesHealthProblem()) {
-                    nodeTypeNames.add(nodeTypeFroResultGroup(statusResult.result.group()));
-                    diagnoses.add(diagnosisForResultGroup(statusResult.result.group()));
+                    nodeTypeNames.add(nodeTypeFroLimitGroup(statusResult.result.group()));
+                    diagnoses.add(diagnosisForLimitGroup(statusResult.result.group()));
                 }
             }
 
@@ -195,7 +195,7 @@ static HealthIndicatorDetails buildDetails(List<ShardLimitValidator.Result> resu
         return (builder, params) -> {
             builder.startObject();
             for (var result : results) {
-                builder.startObject(nodeTypeFroResultGroup(result.group()));
+                builder.startObject(nodeTypeFroLimitGroup(result.group()));
                 builder.field("max_shards_in_cluster", result.maxShardsInCluster());
                 if (result.currentUsedShards().isPresent()) {
                     builder.field("current_used_shards", result.currentUsedShards().get());
@@ -217,7 +217,7 @@ private HealthIndicatorResult unknownIndicator() {
         );
     }
 
-    private static String nodeTypeFroResultGroup(ShardLimitValidator.LimitGroup limitGroup) {
+    private static String nodeTypeFroLimitGroup(ShardLimitValidator.LimitGroup limitGroup) {
         return switch (limitGroup) {
             case NORMAL -> "data";
             case FROZEN -> "frozen";
@@ -226,7 +226,7 @@ private static String nodeTypeFroResultGroup(ShardLimitValidator.LimitGroup limi
         };
     }
 
-    private static Diagnosis diagnosisForResultGroup(ShardLimitValidator.LimitGroup limitGroup) {
+    private static Diagnosis diagnosisForLimitGroup(ShardLimitValidator.LimitGroup limitGroup) {
         return switch (limitGroup) {
             case NORMAL, INDEX, SEARCH -> SHARDS_MAX_CAPACITY_REACHED_DATA_NODES;
             case FROZEN -> SHARDS_MAX_CAPACITY_REACHED_FROZEN_NODES;

server/src/main/java/org/elasticsearch/indices/ShardLimitValidator.java

@@ -116,11 +116,11 @@ public static int getShardLimitPerNode(LimitGroup limitGroup, HealthMetadata.Sha
      * @throws ValidationException if creating this index would put the cluster over the cluster shard limit
      */
     public void validateShardLimit(final Settings settings, final DiscoveryNodes discoveryNodes, final Metadata metadata) {
-        final var resultGroups = applicableLimitGroups(isStateless);
-        final var shardsToCreatePerGroup = resultGroups.stream()
+        final var limitGroups = applicableLimitGroups(isStateless);
+        final var shardsToCreatePerGroup = limitGroups.stream()
             .collect(Collectors.toUnmodifiableMap(Function.identity(), limitGroup -> limitGroup.newShardsTotal(settings)));
 
-        final var result = checkShardLimitOnGroups(resultGroups, shardsToCreatePerGroup, discoveryNodes, metadata);
+        final var result = checkShardLimitOnGroups(limitGroups, shardsToCreatePerGroup, discoveryNodes, metadata);
         if (result.canAddShards == false) {
             final ValidationException e = new ValidationException();
             e.addValidationError(errorMessageFrom(result));
@@ -138,20 +138,20 @@ public void validateShardLimit(final Settings settings, final DiscoveryNodes dis
      * @throws ValidationException If this operation would take the cluster over the limit and enforcement is enabled.
      */
     public void validateShardLimit(DiscoveryNodes discoveryNodes, Metadata metadata, Index[] indicesToOpen) {
-        final var resultGroups = applicableLimitGroups(isStateless);
+        final var limitGroups = applicableLimitGroups(isStateless);
         final Map<LimitGroup, Integer> shardsToCreatePerGroup = new HashMap<>();
 
-        // TODO: we can short circuit when indindicesToOpenices is empty
+        // TODO: we can short circuit when indicesToOpen is empty
         for (Index index : indicesToOpen) {
             IndexMetadata imd = metadata.indexMetadata(index);
             if (imd.getState().equals(IndexMetadata.State.CLOSE)) {
-                resultGroups.forEach(
+                limitGroups.forEach(
                     limitGroup -> shardsToCreatePerGroup.merge(limitGroup, limitGroup.newShardsTotal(imd.getSettings()), Integer::sum)
                 );
             }
         }
 
-        var result = checkShardLimitOnGroups(resultGroups, shardsToCreatePerGroup, discoveryNodes, metadata);
+        var result = checkShardLimitOnGroups(limitGroups, shardsToCreatePerGroup, discoveryNodes, metadata);
         if (result.canAddShards == false) {
             ValidationException ex = new ValidationException();
             ex.addValidationError(errorMessageFrom(result));
@@ -160,18 +160,18 @@ public void validateShardLimit(DiscoveryNodes discoveryNodes, Metadata metadata,
     }
 
     public void validateShardLimitOnReplicaUpdate(DiscoveryNodes discoveryNodes, Metadata metadata, Index[] indices, int replicas) {
-        final var resultGroups = applicableLimitGroups(isStateless);
+        final var limitGroups = applicableLimitGroups(isStateless);
         final Map<LimitGroup, Integer> shardsToCreatePerGroup = new HashMap<>();
 
         // TODO: we can short circuit when indices is empty
         for (Index index : indices) {
             IndexMetadata imd = metadata.indexMetadata(index);
-            resultGroups.forEach(
+            limitGroups.forEach(
                 limitGroup -> shardsToCreatePerGroup.merge(limitGroup, limitGroup.newShardsTotal(imd.getSettings(), replicas), Integer::sum)
             );
         }
 
-        var result = checkShardLimitOnGroups(resultGroups, shardsToCreatePerGroup, discoveryNodes, metadata);
+        var result = checkShardLimitOnGroups(limitGroups, shardsToCreatePerGroup, discoveryNodes, metadata);
         if (result.canAddShards == false) {
             ValidationException ex = new ValidationException();
             ex.addValidationError(errorMessageFrom(result));
@@ -186,12 +186,13 @@ public static List<LimitGroup> applicableLimitGroups(boolean isStateless) {
     /**
      * Checks to see if an operation can be performed without taking the cluster over the cluster-wide shard limit. It follows the
      * next rules:
-     * - Check limits for _normal_ nodes
-     * - If there's no room -> return the Result for _normal_ nodes (fail-fast)
-     * - otherwise -> returns the Result of checking the limits for _frozen_ nodes
+     * - Check limits for nodes in the first group, e.g. _normal_ nodes
+     * - If there's no room -> return the Result for nodes of the first group (fail-fast)
+     * - otherwise -> returns the Result of checking the limits for the next group, e.g. _frozen_ nodes
+     * - Rinse and repeat if thera re more groups. But so far we only have 2 members in a group.
      *
-     * @param limitGroups The applicable result groups to check for shard limits
-     * @param shardsToCreatePerGroup The number of new shards to create per result group
+     * @param limitGroups The applicable limit groups to check for shard limits
+     * @param shardsToCreatePerGroup The number of new shards to create per limit group
      * @param discoveryNodes The nodes in the cluster
      * @param metadata       The cluster state metadata
      */
@@ -202,15 +203,15 @@ private Result checkShardLimitOnGroups(
         Metadata metadata
     ) {
         assert limitGroups.containsAll(shardsToCreatePerGroup.keySet())
-            : "result groups " + limitGroups + " do not contain groups for shards creation " + shardsToCreatePerGroup.keySet();
+            : "limit groups " + limitGroups + " do not contain groups for shards creation " + shardsToCreatePerGroup.keySet();
         // we verify the two limits independently. This also means that if they have mixed frozen and other data-roles nodes, such a mixed
         // node can have both 1000 normal and 3000 frozen shards. This is the trade-off to keep the simplicity of the counts. We advocate
         // against such mixed nodes for production use anyway.
         Result result = null;
-        for (var resultGroup : limitGroups) {
-            result = resultGroup.checkShardLimit(
-                getShardLimitPerNode(resultGroup),
-                shardsToCreatePerGroup.getOrDefault(resultGroup, 0),
+        for (var limitGroup : limitGroups) {
+            result = limitGroup.checkShardLimit(
+                getShardLimitPerNode(limitGroup),
+                shardsToCreatePerGroup.getOrDefault(limitGroup, 0),
                 discoveryNodes,
                 metadata
             );

server/src/test/java/org/elasticsearch/indices/ShardLimitValidatorTests.java

@@ -372,15 +372,15 @@ public static DiscoveryNodes createDiscoveryNodes(int nodesInCluster, LimitGroup
         }
 
         if (group == LimitGroup.INDEX) {
-            // Also add search nodes for index result group and they should not affect the result of the index group
+            // Also add search nodes for index limit group and they should not affect the result of the index group
             IntStream.range(0, nodesInCluster + 1)
                 .forEach(
                     i -> builder.add(
                         DiscoveryNodeUtils.builder(randomAlphaOfLength(16) + i).roles(Set.of(DiscoveryNodeRole.SEARCH_ROLE)).build()
                     )
                 );
         } else if (group == LimitGroup.SEARCH) {
-            // Also add index nodes for search result group and they should not affect the result of the search group
+            // Also add index nodes for search limit group and they should not affect the result of the search group
             IntStream.range(0, nodesInCluster + 1)
                 .forEach(
                     i -> builder.add(