Speed up DiscoveryNodeFilters.trimTier

server/src/main/java/org/elasticsearch/cluster/node/DiscoveryNodeFilters.java

@@ -14,13 +14,13 @@
 import org.elasticsearch.common.regex.Regex;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.transport.TransportAddress;
+import org.elasticsearch.common.util.Maps;
 import org.elasticsearch.core.Nullable;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
-import java.util.stream.Collectors;
 
 public class DiscoveryNodeFilters {
 
@@ -49,7 +49,10 @@ public enum OpType {
     };
 
     public static DiscoveryNodeFilters buildFromKeyValue(OpType opType, Map<String, String> filters) {
-        Map<String, String[]> bFilters = new HashMap<>();
+        if (filters.isEmpty()) {
+            return null;
+        }
+        Map<String, String[]> bFilters = new HashMap<>(filters.size());
         for (Map.Entry<String, String> entry : filters.entrySet()) {
             String[] values = Strings.tokenizeToStringArray(entry.getValue(), ",");
             if (values.length > 0) {
@@ -68,7 +71,7 @@ public static DiscoveryNodeFilters buildFromKeyValue(OpType opType, Map<String,
 
     DiscoveryNodeFilters(OpType opType, Map<String, String[]> filters) {
         this.opType = opType;
-        this.filters = filters;
+        this.filters = Map.copyOf(filters);
     }
 
     private boolean matchByIP(String[] values, @Nullable String hostIp, @Nullable String publishIp) {
@@ -82,6 +85,8 @@ private boolean matchByIP(String[] values, @Nullable String hostIp, @Nullable St
         return false;
     }
 
+    private static final String TIER_PREFERENCE = "_tier_preference";
+
     /**
      * Removes any filters that should not be considered, returning a new
      * {@link DiscoveryNodeFilters} object. If the filtered object has no
@@ -92,20 +97,14 @@ public static DiscoveryNodeFilters trimTier(@Nullable DiscoveryNodeFilters origi
         if (original == null) {
             return null;
         }
-
-        Map<String, String[]> newFilters = original.filters.entrySet().stream()
+        if (original.filters.containsKey(TIER_PREFERENCE)) {
             // Remove all entries that use "_tier_preference", as these will be handled elsewhere
-            .filter(entry -> {
-                String attr = entry.getKey();
-                return attr != null && attr.equals("_tier_preference") == false;
-            })
-            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-
-        if (newFilters.size() == 0) {
-            return null;
-        } else {
-            return new DiscoveryNodeFilters(original.opType, newFilters);
+            if (original.filters.size() == 1) {
+                return null;
+            }
+            return new DiscoveryNodeFilters(original.opType, Maps.copyMapWithRemovedEntry(original.filters, TIER_PREFERENCE));
         }
+        return original;
     }
 
     public boolean match(DiscoveryNode node) {

server/src/main/java/org/elasticsearch/common/util/Maps.java

@@ -81,12 +81,27 @@ public static <K, V> Map<K, V> copyMapWithAddedOrReplacedEntry(final Map<K, V> m
      * @param <V>   the type of the values in the map
      * @return an immutable map that contains the items from the specified map with the provided key removed
      */
+    @SuppressWarnings("unchecked")
     public static <K, V> Map<K, V> copyMapWithRemovedEntry(final Map<K, V> map, final K key) {
         Objects.requireNonNull(map);
         Objects.requireNonNull(key);
         assert checkIsImmutableMap(map, key, map.get(key));
-        return map.entrySet().stream().filter(k -> key.equals(k.getKey()) == false)
-            .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue));
+        if (map.containsKey(key) == false) {
+            return map;
+        }
+        final int size = map.size();
+        if (size == 1) {
+            return Map.of();
+        }
+        @SuppressWarnings("rawtypes")
+        final Map.Entry<K, V>[] entries = new Map.Entry[size - 1];
+        int i = 0;
+        for (Map.Entry<K, V> entry : map.entrySet()) {
+            if (key.equals(entry.getKey()) == false) {
+                entries[i++] = entry;
+            }
+        }
+        return Map.ofEntries(entries);
     }
 
     // map classes that are known to be immutable, used to speed up immutability check in #assertImmutableMap
@@ -154,7 +169,6 @@ public static <K, V> boolean deepEquals(Map<K, V> left, Map<K, V> right) {
      * @param map - input to be flattened
      * @param flattenArrays - if false, arrays will be ignored
      * @param ordered - if true the resulted map will be sorted
-     * @return
      */
     public static Map<String, Object> flatten(Map<String, Object> map, boolean flattenArrays, boolean ordered) {
         return flatten(map, flattenArrays, ordered, null);

server/src/test/java/org/elasticsearch/common/util/MapsTests.java

@@ -28,6 +28,7 @@
 
 import static java.util.Map.entry;
 import static java.util.stream.Collectors.toMap;
+import static org.hamcrest.Matchers.anEmptyMap;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.hasItem;
@@ -190,6 +191,16 @@ public void testFlatten() {
         }
     }
 
+    public void testCopyMapWithAddedOrReplacedEntry() {
+        final Map<String, String> start = Map.of("foo", "bar", "blub", "bla");
+        final Map<String, String> removeMissing = Maps.copyMapWithRemovedEntry(start, "missing");
+        assertSame(start, removeMissing);
+        final Map<String, String> removeFoo = Maps.copyMapWithRemovedEntry(start, "foo");
+        assertThat(removeFoo, equalTo(Map.of("blub", "bla")));
+        final Map<String, String> removeBlub = Maps.copyMapWithRemovedEntry(removeFoo, "blub");
+        assertThat(removeBlub, anEmptyMap());
+    }
+
     @SuppressWarnings("unchecked")
     private static Object deepGet(String path, Object obj) {
         Object cur = obj;