From 02a5cdc192ea16c3fa2f7f75167320c77c74648f Mon Sep 17 00:00:00 2001 From: kewei03 Date: Sun, 8 Dec 2019 17:36:10 +0800 Subject: [PATCH 1/7] fix issue-49818 --- .../service/ClusterApplierService.java | 2 +- .../settings/AbstractScopedSettings.java | 29 ++++++++++---- .../common/settings/ClusterSettings.java | 2 +- .../common/settings/Setting.java | 39 ++++++++++++------- .../elasticsearch/index/IndexSettings.java | 2 +- .../common/settings/SettingsFilterTests.java | 4 +- 6 files changed, 51 insertions(+), 27 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java index 574919f6751ab..69802ebb83c4d 100644 --- a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java +++ b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java @@ -477,7 +477,7 @@ private void applyChanges(UpdateTask task, ClusterState previousClusterState, Cl logger.debug("applying settings from cluster state with version {}", newClusterState.version()); final Settings incomingSettings = clusterChangedEvent.state().metaData().settings(); try (Releasable ignored = stopWatch.timing("applying settings")) { - clusterSettings.applySettings(incomingSettings); + clusterSettings.applySettings("cluster", incomingSettings); } } diff --git a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java index 1cbdc29bb1654..7f88bb4043eb6 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java @@ -171,6 +171,15 @@ public synchronized Settings validateUpdate(Settings settings) { * @return the unmerged applied settings */ public synchronized Settings applySettings(Settings newSettings) { + return applySettings(null, newSettings); + } + + /** + * @param target the target to be applied newSettings + * @param newSettings the settings to apply + * @return the unmerged applied settings + */ + public synchronized Settings applySettings(String target, Settings newSettings) { if (lastSettingsApplied != null && newSettings.equals(lastSettingsApplied)) { // nothing changed in the settings, ignore return newSettings; @@ -181,7 +190,7 @@ public synchronized Settings applySettings(Settings newSettings) { List applyRunnables = new ArrayList<>(); for (SettingUpdater settingUpdater : settingUpdaters) { try { - applyRunnables.add(settingUpdater.updater(current, previous)); + applyRunnables.add(settingUpdater.updater(target, current, previous)); } catch (Exception ex) { logger.warn(() -> new ParameterizedMessage("failed to prepareCommit settings for [{}]", settingUpdater), ex); throw ex; @@ -287,7 +296,7 @@ public Map> getValue(Settings current, Settings previous) { } @Override - public void apply(Map> values, Settings current, Settings previous) { + public void apply(String target, Map> values, Settings current, Settings previous) { for (Map.Entry> entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -336,7 +345,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(Map values, Settings current, Settings previous) { + public void apply(String target, Map values, Settings current, Settings previous) { for (Map.Entry entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -584,30 +593,34 @@ public interface SettingUpdater { /** * Applies the given value to the updater. This methods will actually run the update. */ - void apply(T value, Settings current, Settings previous); + void apply(String target, T value, Settings current, Settings previous); /** * Updates this updaters value if it has changed. * @return true iff the value has been updated. */ default boolean apply(Settings current, Settings previous) { + return apply(null, current, previous); + } + + default boolean apply(String target, Settings current, Settings previous) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - apply(value, current, previous); + apply(target, value, current, previous); return true; } return false; } /** - * Returns a callable runnable that calls {@link #apply(Object, Settings, Settings)} if the settings + * Returns a callable runnable that calls {@link #apply(String, Object, Settings, Settings)} if the settings * actually changed. This allows to defer the update to a later point in time while keeping type safety. * If the value didn't change the returned runnable is a noop. */ - default Runnable updater(Settings current, Settings previous) { + default Runnable updater(String target, Settings current, Settings previous) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - return () -> { apply(value, current, previous);}; + return () -> { apply(target, value, current, previous);}; } return () -> {}; } diff --git a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java index ef40f05a2f261..497b7227376d1 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java @@ -158,7 +158,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous) { + public void apply(String target, Settings value, Settings current, Settings previous) { for (String key : value.keySet()) { assert loggerPredicate.test(key); String component = key.substring("logger.".length()); diff --git a/server/src/main/java/org/elasticsearch/common/settings/Setting.java b/server/src/main/java/org/elasticsearch/common/settings/Setting.java index 2e6bfdc635cd2..1157ffa5d57f2 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/Setting.java +++ b/server/src/main/java/org/elasticsearch/common/settings/Setting.java @@ -614,12 +614,12 @@ public Tuple getValue(Settings current, Settings previous) { } @Override - public void apply(Tuple value, Settings current, Settings previous) { + public void apply(String target, Tuple value, Settings current, Settings previous) { if (aSettingUpdater.hasChanged(current, previous)) { - logSettingUpdate(aSetting, current, previous, logger); + logSettingUpdate(target, aSetting, current, previous, logger); } if (bSettingUpdater.hasChanged(current, previous)) { - logSettingUpdate(bSetting, current, previous, logger); + logSettingUpdate(target, bSetting, current, previous, logger); } consumer.accept(value.v1(), value.v2()); } @@ -660,7 +660,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous) { + public void apply(String target, Settings value, Settings current, Settings previous) { consumer.accept(value); } @@ -732,9 +732,10 @@ public Map, T> getValue(Settings curren } @Override - public void apply(Map, T> value, Settings current, Settings previous) { + public void apply(String target, Map, T> value, + Settings current, Settings previous) { for (Map.Entry, T> entry : value.entrySet()) { - entry.getKey().apply(entry.getValue(), current, previous); + entry.getKey().apply(target, entry.getValue(), current, previous); } } }; @@ -769,7 +770,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(Map value, Settings current, Settings previous) { + public void apply(String target, Map value, Settings current, Settings previous) { consumer.accept(value); } }; @@ -994,8 +995,8 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous) { - Setting.logSettingUpdate(GroupSetting.this, current, previous, logger); + public void apply(String target, Settings value, Settings current, Settings previous) { + Setting.logSettingUpdate(target, GroupSetting.this, current, previous, logger); consumer.accept(value); } @@ -1052,8 +1053,8 @@ public T getValue(Settings current, Settings previous) { } @Override - public void apply(T value, Settings current, Settings previous) { - logSettingUpdate(Setting.this, current, previous, logger); + public void apply(String target, T value, Settings current, Settings previous) { + logSettingUpdate(target, Setting.this, current, previous, logger); consumer.accept(value); } } @@ -1463,12 +1464,22 @@ public void diff(Settings.Builder builder, Settings source, Settings defaultSett } } - static void logSettingUpdate(Setting setting, Settings current, Settings previous, Logger logger) { + static void logSettingUpdate(String target, Setting setting, Settings current, Settings previous, Logger logger) { if (logger.isInfoEnabled()) { if (setting.isFiltered()) { - logger.info("updating [{}]", setting.key); + if (target == null) { + logger.info("updating [{}]", setting.key); + } else { + logger.info("updating [{}] [{}]", target, setting.key); + + } } else { - logger.info("updating [{}] from [{}] to [{}]", setting.key, setting.getRaw(previous), setting.getRaw(current)); + if (target == null) { + logger.info("updating [{}] from [{}] to [{}]", setting.key, setting.getRaw(previous), setting.getRaw(current)); + } else { + logger.info("updating [{}] [{}] from [{}] to [{}]", + target, setting.key, setting.getRaw(previous), setting.getRaw(current)); + } } } } diff --git a/server/src/main/java/org/elasticsearch/index/IndexSettings.java b/server/src/main/java/org/elasticsearch/index/IndexSettings.java index a1994d65c8d73..e0e1847bdf5b8 100644 --- a/server/src/main/java/org/elasticsearch/index/IndexSettings.java +++ b/server/src/main/java/org/elasticsearch/index/IndexSettings.java @@ -702,7 +702,7 @@ public synchronized boolean updateIndexMetaData(IndexMetaData indexMetaData) { // nothing to update, same settings return false; } - scopedSettings.applySettings(newSettings); + scopedSettings.applySettings(indexMetaData.getIndex().getName(), newSettings); this.settings = newIndexSettings; return true; } diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java index 9c94bfab7acd6..fd9f54c18c426 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java @@ -114,7 +114,7 @@ public void testFilteredSettingIsNotLogged() throws Exception { Settings newSettings = Settings.builder().put("key", "new").build(); Setting filteredSetting = Setting.simpleString("key", Property.Filtered); - assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate(filteredSetting, newSettings, oldSettings, testLogger), + assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate("index1", filteredSetting, newSettings, oldSettings, testLogger), new MockLogAppender.SeenEventExpectation("secure logging", "org.elasticsearch.test", Level.INFO, "updating [key]"), new MockLogAppender.UnseenEventExpectation("unwanted old setting name", "org.elasticsearch.test", Level.INFO, "*old*"), new MockLogAppender.UnseenEventExpectation("unwanted new setting name", "org.elasticsearch.test", Level.INFO, "*new*") @@ -126,7 +126,7 @@ public void testRegularSettingUpdateIsFullyLogged() throws Exception { Settings newSettings = Settings.builder().put("key", "new").build(); Setting regularSetting = Setting.simpleString("key"); - assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate(regularSetting, newSettings, oldSettings, testLogger), + assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate("index1", regularSetting, newSettings, oldSettings, testLogger), new MockLogAppender.SeenEventExpectation("regular logging", "org.elasticsearch.test", Level.INFO, "updating [key] from [old] to [new]")); } From f987ce0fb43713c02d1a6e835c5afeff4c440772 Mon Sep 17 00:00:00 2001 From: kewei03 Date: Tue, 10 Dec 2019 13:56:06 +0800 Subject: [PATCH 2/7] add prefix to logger --- .../service/ClusterApplierService.java | 2 +- .../settings/AbstractScopedSettings.java | 40 +++++++------------ .../common/settings/ClusterSettings.java | 4 +- .../common/settings/IndexScopedSettings.java | 8 +++- .../common/settings/Setting.java | 39 +++++++----------- .../elasticsearch/index/IndexSettings.java | 2 +- .../common/settings/SettingsFilterTests.java | 4 +- .../test/IndexSettingsModule.java | 5 ++- .../security/authc/RealmSettingsTests.java | 2 +- 9 files changed, 45 insertions(+), 61 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java index 69802ebb83c4d..574919f6751ab 100644 --- a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java +++ b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java @@ -477,7 +477,7 @@ private void applyChanges(UpdateTask task, ClusterState previousClusterState, Cl logger.debug("applying settings from cluster state with version {}", newClusterState.version()); final Settings incomingSettings = clusterChangedEvent.state().metaData().settings(); try (Releasable ignored = stopWatch.timing("applying settings")) { - clusterSettings.applySettings("cluster", incomingSettings); + clusterSettings.applySettings(incomingSettings); } } diff --git a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java index 7f88bb4043eb6..41f9b112239fb 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java @@ -19,13 +19,13 @@ package org.elasticsearch.common.settings; -import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.message.ParameterizedMessage; import org.apache.lucene.search.spell.LevenshteinDistance; import org.apache.lucene.util.CollectionUtil; import org.elasticsearch.ExceptionsHelper; import org.elasticsearch.common.collect.Tuple; +import org.elasticsearch.common.logging.Loggers; import org.elasticsearch.common.regex.Regex; import java.util.ArrayList; @@ -55,7 +55,7 @@ public abstract class AbstractScopedSettings { private static final Pattern GROUP_KEY_PATTERN = Pattern.compile("^(?:[-\\w]+[.])+$"); private static final Pattern AFFIX_KEY_PATTERN = Pattern.compile("^(?:[-\\w]+[.])+[*](?:[.][-\\w]+)+$"); - protected final Logger logger = LogManager.getLogger(this.getClass()); + protected final Logger logger; private final Settings settings; private final List> settingUpdaters = new CopyOnWriteArrayList<>(); @@ -69,7 +69,9 @@ protected AbstractScopedSettings( final Settings settings, final Set> settingsSet, final Set> settingUpgraders, - final Setting.Property scope) { + final Setting.Property scope, + final String prefix) { + this.logger = Loggers.getLogger(this.getClass(), prefix); this.settings = settings; this.lastSettingsApplied = Settings.EMPTY; @@ -110,7 +112,8 @@ protected void validateSettingKey(Setting setting) { } } - protected AbstractScopedSettings(Settings nodeSettings, Settings scopeSettings, AbstractScopedSettings other) { + protected AbstractScopedSettings(Settings nodeSettings, Settings scopeSettings, AbstractScopedSettings other, String prefix) { + this.logger = Loggers.getLogger(this.getClass(), prefix); this.settings = nodeSettings; this.lastSettingsApplied = scopeSettings; this.scope = other.scope; @@ -171,15 +174,6 @@ public synchronized Settings validateUpdate(Settings settings) { * @return the unmerged applied settings */ public synchronized Settings applySettings(Settings newSettings) { - return applySettings(null, newSettings); - } - - /** - * @param target the target to be applied newSettings - * @param newSettings the settings to apply - * @return the unmerged applied settings - */ - public synchronized Settings applySettings(String target, Settings newSettings) { if (lastSettingsApplied != null && newSettings.equals(lastSettingsApplied)) { // nothing changed in the settings, ignore return newSettings; @@ -190,7 +184,7 @@ public synchronized Settings applySettings(String target, Settings newSettings) List applyRunnables = new ArrayList<>(); for (SettingUpdater settingUpdater : settingUpdaters) { try { - applyRunnables.add(settingUpdater.updater(target, current, previous)); + applyRunnables.add(settingUpdater.updater(current, previous)); } catch (Exception ex) { logger.warn(() -> new ParameterizedMessage("failed to prepareCommit settings for [{}]", settingUpdater), ex); throw ex; @@ -296,7 +290,7 @@ public Map> getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Map> values, Settings current, Settings previous) { + public void apply(Map> values, Settings current, Settings previous) { for (Map.Entry> entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -345,7 +339,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Map values, Settings current, Settings previous) { + public void apply(Map values, Settings current, Settings previous) { for (Map.Entry entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -593,34 +587,30 @@ public interface SettingUpdater { /** * Applies the given value to the updater. This methods will actually run the update. */ - void apply(String target, T value, Settings current, Settings previous); + void apply(T value, Settings current, Settings previous); /** * Updates this updaters value if it has changed. * @return true iff the value has been updated. */ default boolean apply(Settings current, Settings previous) { - return apply(null, current, previous); - } - - default boolean apply(String target, Settings current, Settings previous) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - apply(target, value, current, previous); + apply(value, current, previous); return true; } return false; } /** - * Returns a callable runnable that calls {@link #apply(String, Object, Settings, Settings)} if the settings + * Returns a callable runnable that calls {@link #apply(Object, Settings, Settings)} if the settings * actually changed. This allows to defer the update to a later point in time while keeping type safety. * If the value didn't change the returned runnable is a noop. */ - default Runnable updater(String target, Settings current, Settings previous) { + default Runnable updater(Settings current, Settings previous) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - return () -> { apply(target, value, current, previous);}; + return () -> { apply(value, current, previous);}; } return () -> {}; } diff --git a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java index 497b7227376d1..cb1de5c5982f1 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java @@ -124,7 +124,7 @@ public ClusterSettings(final Settings nodeSettings, final Set> settin } public ClusterSettings(final Settings nodeSettings, final Set> settingsSet, final Set> settingUpgraders) { - super(nodeSettings, settingsSet, settingUpgraders, Property.NodeScope); + super(nodeSettings, settingsSet, settingUpgraders, Property.NodeScope, "cluster"); addSettingsUpdater(new LoggingSettingUpdater(nodeSettings)); } @@ -158,7 +158,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Settings value, Settings current, Settings previous) { + public void apply(Settings value, Settings current, Settings previous) { for (String key : value.keySet()) { assert loggerPredicate.test(key); String component = key.substring("logger.".length()); diff --git a/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java index f83012f2db32b..b0d8fb2ea0566 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java @@ -182,11 +182,15 @@ public final class IndexScopedSettings extends AbstractScopedSettings { public static final IndexScopedSettings DEFAULT_SCOPED_SETTINGS = new IndexScopedSettings(Settings.EMPTY, BUILT_IN_INDEX_SETTINGS); public IndexScopedSettings(Settings settings, Set> settingsSet) { - super(settings, settingsSet, Collections.emptySet(), Property.IndexScope); + super(settings, settingsSet, Collections.emptySet(), Property.IndexScope, "indexScopedSettings"); + } + + public IndexScopedSettings(Settings settings, Set> settingsSet, String prefix) { + super(settings, settingsSet, Collections.emptySet(), Property.IndexScope, prefix); } private IndexScopedSettings(Settings settings, IndexScopedSettings other, IndexMetaData metaData) { - super(settings, metaData.getSettings(), other); + super(settings, metaData.getSettings(), other, metaData.getIndex().getName()); } public IndexScopedSettings copy(Settings settings, IndexMetaData metaData) { diff --git a/server/src/main/java/org/elasticsearch/common/settings/Setting.java b/server/src/main/java/org/elasticsearch/common/settings/Setting.java index 1157ffa5d57f2..2e6bfdc635cd2 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/Setting.java +++ b/server/src/main/java/org/elasticsearch/common/settings/Setting.java @@ -614,12 +614,12 @@ public Tuple getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Tuple value, Settings current, Settings previous) { + public void apply(Tuple value, Settings current, Settings previous) { if (aSettingUpdater.hasChanged(current, previous)) { - logSettingUpdate(target, aSetting, current, previous, logger); + logSettingUpdate(aSetting, current, previous, logger); } if (bSettingUpdater.hasChanged(current, previous)) { - logSettingUpdate(target, bSetting, current, previous, logger); + logSettingUpdate(bSetting, current, previous, logger); } consumer.accept(value.v1(), value.v2()); } @@ -660,7 +660,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Settings value, Settings current, Settings previous) { + public void apply(Settings value, Settings current, Settings previous) { consumer.accept(value); } @@ -732,10 +732,9 @@ public Map, T> getValue(Settings curren } @Override - public void apply(String target, Map, T> value, - Settings current, Settings previous) { + public void apply(Map, T> value, Settings current, Settings previous) { for (Map.Entry, T> entry : value.entrySet()) { - entry.getKey().apply(target, entry.getValue(), current, previous); + entry.getKey().apply(entry.getValue(), current, previous); } } }; @@ -770,7 +769,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Map value, Settings current, Settings previous) { + public void apply(Map value, Settings current, Settings previous) { consumer.accept(value); } }; @@ -995,8 +994,8 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(String target, Settings value, Settings current, Settings previous) { - Setting.logSettingUpdate(target, GroupSetting.this, current, previous, logger); + public void apply(Settings value, Settings current, Settings previous) { + Setting.logSettingUpdate(GroupSetting.this, current, previous, logger); consumer.accept(value); } @@ -1053,8 +1052,8 @@ public T getValue(Settings current, Settings previous) { } @Override - public void apply(String target, T value, Settings current, Settings previous) { - logSettingUpdate(target, Setting.this, current, previous, logger); + public void apply(T value, Settings current, Settings previous) { + logSettingUpdate(Setting.this, current, previous, logger); consumer.accept(value); } } @@ -1464,22 +1463,12 @@ public void diff(Settings.Builder builder, Settings source, Settings defaultSett } } - static void logSettingUpdate(String target, Setting setting, Settings current, Settings previous, Logger logger) { + static void logSettingUpdate(Setting setting, Settings current, Settings previous, Logger logger) { if (logger.isInfoEnabled()) { if (setting.isFiltered()) { - if (target == null) { - logger.info("updating [{}]", setting.key); - } else { - logger.info("updating [{}] [{}]", target, setting.key); - - } + logger.info("updating [{}]", setting.key); } else { - if (target == null) { - logger.info("updating [{}] from [{}] to [{}]", setting.key, setting.getRaw(previous), setting.getRaw(current)); - } else { - logger.info("updating [{}] [{}] from [{}] to [{}]", - target, setting.key, setting.getRaw(previous), setting.getRaw(current)); - } + logger.info("updating [{}] from [{}] to [{}]", setting.key, setting.getRaw(previous), setting.getRaw(current)); } } } diff --git a/server/src/main/java/org/elasticsearch/index/IndexSettings.java b/server/src/main/java/org/elasticsearch/index/IndexSettings.java index e0e1847bdf5b8..a1994d65c8d73 100644 --- a/server/src/main/java/org/elasticsearch/index/IndexSettings.java +++ b/server/src/main/java/org/elasticsearch/index/IndexSettings.java @@ -702,7 +702,7 @@ public synchronized boolean updateIndexMetaData(IndexMetaData indexMetaData) { // nothing to update, same settings return false; } - scopedSettings.applySettings(indexMetaData.getIndex().getName(), newSettings); + scopedSettings.applySettings(newSettings); this.settings = newIndexSettings; return true; } diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java index fd9f54c18c426..9c94bfab7acd6 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingsFilterTests.java @@ -114,7 +114,7 @@ public void testFilteredSettingIsNotLogged() throws Exception { Settings newSettings = Settings.builder().put("key", "new").build(); Setting filteredSetting = Setting.simpleString("key", Property.Filtered); - assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate("index1", filteredSetting, newSettings, oldSettings, testLogger), + assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate(filteredSetting, newSettings, oldSettings, testLogger), new MockLogAppender.SeenEventExpectation("secure logging", "org.elasticsearch.test", Level.INFO, "updating [key]"), new MockLogAppender.UnseenEventExpectation("unwanted old setting name", "org.elasticsearch.test", Level.INFO, "*old*"), new MockLogAppender.UnseenEventExpectation("unwanted new setting name", "org.elasticsearch.test", Level.INFO, "*new*") @@ -126,7 +126,7 @@ public void testRegularSettingUpdateIsFullyLogged() throws Exception { Settings newSettings = Settings.builder().put("key", "new").build(); Setting regularSetting = Setting.simpleString("key"); - assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate("index1", regularSetting, newSettings, oldSettings, testLogger), + assertExpectedLogMessages((testLogger) -> Setting.logSettingUpdate(regularSetting, newSettings, oldSettings, testLogger), new MockLogAppender.SeenEventExpectation("regular logging", "org.elasticsearch.test", Level.INFO, "updating [key] from [old] to [new]")); } diff --git a/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java b/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java index 0badefd978bd3..c746b7d9c9be1 100644 --- a/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java +++ b/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java @@ -67,7 +67,7 @@ public static IndexSettings newIndexSettings(Index index, Settings indexSetting, if (setting.length > 0) { settingSet.addAll(Arrays.asList(setting)); } - return new IndexSettings(metaData, nodeSettings, new IndexScopedSettings(Settings.EMPTY, settingSet)); + return new IndexSettings(metaData, nodeSettings, new IndexScopedSettings(Settings.EMPTY, settingSet, index.getName())); } public static IndexSettings newIndexSettings(Index index, Settings settings, IndexScopedSettings indexScopedSettings) { @@ -85,6 +85,7 @@ public static IndexSettings newIndexSettings(final IndexMetaData indexMetaData, if (setting.length > 0) { settingSet.addAll(Arrays.asList(setting)); } - return new IndexSettings(indexMetaData, Settings.EMPTY, new IndexScopedSettings(Settings.EMPTY, settingSet)); + return new IndexSettings(indexMetaData, Settings.EMPTY, + new IndexScopedSettings(Settings.EMPTY, settingSet, indexMetaData.getIndex().getName())); } } diff --git a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java index d5e123c2313bb..3a7eb2b26d85d 100644 --- a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java +++ b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java @@ -317,7 +317,7 @@ private IllegalArgumentException assertError(String realmType, String realmName, private void validate(Settings settings) { final Set> settingsSet = new HashSet<>(InternalRealmsSettings.getSettings()); final AbstractScopedSettings validator = new AbstractScopedSettings(settings, settingsSet, Collections.emptySet(), - Setting.Property.NodeScope) { + Setting.Property.NodeScope, "realm") { }; validator.validate(settings, false); } From ec0bb37df6b9c9f0d8c6966341797ecc82217299 Mon Sep 17 00:00:00 2001 From: kewei03 Date: Tue, 10 Dec 2019 18:21:48 +0800 Subject: [PATCH 3/7] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=8D=95=E5=85=83?= =?UTF-8?q?=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../common/settings/SettingTests.java | 49 +++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java index 4ad401454b914..d6c97f4aaeb55 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java @@ -18,12 +18,21 @@ */ package org.elasticsearch.common.settings; +import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.core.LogEvent; +import org.apache.logging.log4j.core.appender.AbstractAppender; +import org.apache.logging.log4j.core.filter.RegexFilter; +import org.apache.logging.log4j.core.impl.MementoMessage; +import org.elasticsearch.Version; +import org.elasticsearch.cluster.metadata.IndexMetaData; import org.elasticsearch.common.collect.Tuple; +import org.elasticsearch.common.logging.Loggers; import org.elasticsearch.common.settings.AbstractScopedSettings.SettingUpdater; import org.elasticsearch.common.settings.Setting.Property; import org.elasticsearch.common.unit.ByteSizeUnit; import org.elasticsearch.common.unit.ByteSizeValue; import org.elasticsearch.common.unit.TimeValue; +import org.elasticsearch.index.IndexSettings; import org.elasticsearch.monitor.jvm.JvmInfo; import org.elasticsearch.test.ESTestCase; @@ -40,6 +49,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import static org.elasticsearch.index.IndexSettingsTests.newIndexMeta; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.hasSize; @@ -49,6 +59,27 @@ public class SettingTests extends ESTestCase { + public static class MockAppender extends AbstractAppender { + private LogEvent lastEvent; + + public MockAppender(final String name) throws IllegalAccessException { + super(name, RegexFilter.createFilter(".*(\n.*)*", new String[0], false, null, null), null); + } + + @Override + public void append(LogEvent event) { + lastEvent = event.toImmutable(); + } + + public MementoMessage lastMementoMessage() { + return (MementoMessage) lastEvent.getMessage(); + } + + public String getLoggerMaker() { + return lastEvent.getMarker().getName(); + } + } + public void testGet() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope); assertFalse(booleanSetting.get(Settings.EMPTY)); @@ -1092,4 +1123,22 @@ public void testNonSecureSettingInKeystore() { assertThat(e.getMessage(), containsString("must be stored inside elasticsearch.yml")); } + public void testLogSettingUpdate() throws Exception { + IndexMetaData metaData = newIndexMeta("index1", Settings.builder() + .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT) + .put(IndexSettings.INDEX_WARMER_ENABLED_SETTING.getKey(), false) + .build()); + IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY); + Logger logger = settings.getScopedSettings().logger; + + MockAppender appender = new MockAppender("trace_appender"); + appender.start(); + Loggers.addAppender(logger, appender); + + settings.updateIndexMetaData(newIndexMeta("index1", Settings.builder().put(IndexSettings.INDEX_WARMER_ENABLED_SETTING.getKey(), + "true").build())); + + assertThat(appender.lastMementoMessage().getFormattedMessage(), equalTo("updating [index.warmer.enabled] from [false] to [true]")); + assertThat(appender.getLoggerMaker(), equalTo("[index1]")); + } } From 5a9b7056fb0905c37cf6706c8663a4a544491b45 Mon Sep 17 00:00:00 2001 From: kewei03 Date: Tue, 10 Dec 2019 20:01:17 +0800 Subject: [PATCH 4/7] subclasses privide their own logger --- .../service/ClusterApplierService.java | 2 +- .../settings/AbstractScopedSettings.java | 57 +++++---- .../common/settings/ClusterSettings.java | 5 +- .../common/settings/IndexScopedSettings.java | 6 +- .../common/settings/Setting.java | 44 ++++--- .../elasticsearch/index/IndexSettings.java | 9 +- .../action/support/AutoCreateIndexTests.java | 4 +- .../NoMasterBlockServiceTests.java | 2 +- .../coordination/ReconfiguratorTests.java | 8 +- .../allocation/BalanceConfigurationTests.java | 4 +- .../DiskThresholdSettingsTests.java | 20 ++-- .../decider/EnableAllocationTests.java | 4 +- .../common/settings/ScopedSettingsTests.java | 52 ++++---- .../common/settings/SettingTests.java | 113 +++++++++--------- .../IncrementalClusterStateWriterTests.java | 2 +- .../index/shard/IndexShardTests.java | 12 +- .../RecoverySettingsDynamicUpdateTests.java | 12 +- .../PersistentTasksDecidersTestCase.java | 2 +- .../script/ScriptServiceTests.java | 6 +- .../AbstractSimpleTransportTestCase.java | 2 +- .../monitoring/exporter/ExportersTests.java | 2 +- .../security/authc/RealmSettingsTests.java | 2 +- .../transport/filter/IPFilterTests.java | 2 +- .../watcher/common/http/HttpClientTests.java | 2 +- 24 files changed, 192 insertions(+), 182 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java index 574919f6751ab..eb629f2b5086a 100644 --- a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java +++ b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java @@ -477,7 +477,7 @@ private void applyChanges(UpdateTask task, ClusterState previousClusterState, Cl logger.debug("applying settings from cluster state with version {}", newClusterState.version()); final Settings incomingSettings = clusterChangedEvent.state().metaData().settings(); try (Releasable ignored = stopWatch.timing("applying settings")) { - clusterSettings.applySettings(incomingSettings); + clusterSettings.applySettings(incomingSettings, logger); } } diff --git a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java index 41f9b112239fb..39e0657638d64 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java @@ -19,13 +19,13 @@ package org.elasticsearch.common.settings; +import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.message.ParameterizedMessage; import org.apache.lucene.search.spell.LevenshteinDistance; import org.apache.lucene.util.CollectionUtil; import org.elasticsearch.ExceptionsHelper; import org.elasticsearch.common.collect.Tuple; -import org.elasticsearch.common.logging.Loggers; import org.elasticsearch.common.regex.Regex; import java.util.ArrayList; @@ -55,7 +55,7 @@ public abstract class AbstractScopedSettings { private static final Pattern GROUP_KEY_PATTERN = Pattern.compile("^(?:[-\\w]+[.])+$"); private static final Pattern AFFIX_KEY_PATTERN = Pattern.compile("^(?:[-\\w]+[.])+[*](?:[.][-\\w]+)+$"); - protected final Logger logger; + protected final Logger logger = LogManager.getLogger(this.getClass()); private final Settings settings; private final List> settingUpdaters = new CopyOnWriteArrayList<>(); @@ -69,9 +69,7 @@ protected AbstractScopedSettings( final Settings settings, final Set> settingsSet, final Set> settingUpgraders, - final Setting.Property scope, - final String prefix) { - this.logger = Loggers.getLogger(this.getClass(), prefix); + final Setting.Property scope) { this.settings = settings; this.lastSettingsApplied = Settings.EMPTY; @@ -112,8 +110,7 @@ protected void validateSettingKey(Setting setting) { } } - protected AbstractScopedSettings(Settings nodeSettings, Settings scopeSettings, AbstractScopedSettings other, String prefix) { - this.logger = Loggers.getLogger(this.getClass(), prefix); + protected AbstractScopedSettings(Settings nodeSettings, Settings scopeSettings, AbstractScopedSettings other) { this.settings = nodeSettings; this.lastSettingsApplied = scopeSettings; this.scope = other.scope; @@ -173,7 +170,7 @@ public synchronized Settings validateUpdate(Settings settings) { * @param newSettings the settings to apply * @return the unmerged applied settings */ - public synchronized Settings applySettings(Settings newSettings) { + public synchronized Settings applySettings(Settings newSettings, Logger logger) { if (lastSettingsApplied != null && newSettings.equals(lastSettingsApplied)) { // nothing changed in the settings, ignore return newSettings; @@ -184,7 +181,7 @@ public synchronized Settings applySettings(Settings newSettings) { List applyRunnables = new ArrayList<>(); for (SettingUpdater settingUpdater : settingUpdaters) { try { - applyRunnables.add(settingUpdater.updater(current, previous)); + applyRunnables.add(settingUpdater.updater(current, previous, logger)); } catch (Exception ex) { logger.warn(() -> new ParameterizedMessage("failed to prepareCommit settings for [{}]", settingUpdater), ex); throw ex; @@ -212,7 +209,7 @@ public synchronized void addSettingsUpdateConsumer(Setting setting, Consu if (setting != get(setting.getKey())) { throw new IllegalArgumentException("Setting is not registered for key [" + setting.getKey() + "]"); } - addSettingsUpdater(setting.newUpdater(consumer, logger, validator)); + addSettingsUpdater(setting.newUpdater(consumer, validator)); } /** @@ -232,7 +229,7 @@ public synchronized void addSettingsUpdateConsumer(Consumer consumer, public synchronized void addAffixUpdateConsumer(Setting.AffixSetting setting, BiConsumer consumer, BiConsumer validator) { ensureSettingIsRegistered(setting); - addSettingsUpdater(setting.newAffixUpdater(consumer, logger, validator)); + addSettingsUpdater(setting.newAffixUpdater(consumer, validator)); } /** @@ -251,8 +248,8 @@ public synchronized void addAffixUpdateConsumer(Setting.AffixSetting se // down the road this would be nice to have! ensureSettingIsRegistered(settingA); ensureSettingIsRegistered(settingB); - SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {}); - SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {}); + SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater((a,b)-> {}, (a,b)-> {}); + SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater((a,b)-> {}, (a,b)-> {}); addSettingsUpdater(new SettingUpdater>>() { @@ -279,10 +276,10 @@ public Map> getValue(Settings current, Settings previous) { map.put(key, new Tuple<>(settingA.getConcreteSettingForNamespace(key).get(current), value)); } }; - SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater(aConsumer, logger, (a,b) ->{}); - SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater(bConsumer, logger, (a,b) ->{}); - affixUpdaterA.apply(current, previous); - affixUpdaterB.apply(current, previous); + SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater(aConsumer, (a,b) ->{}); + SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater(bConsumer, (a,b) ->{}); + affixUpdaterA.apply(current, previous, logger); + affixUpdaterB.apply(current, previous, logger); for (Map.Entry> entry : map.entrySet()) { validator.accept(entry.getKey(), entry.getValue()); } @@ -290,7 +287,7 @@ public Map> getValue(Settings current, Settings previous) { } @Override - public void apply(Map> values, Settings current, Settings previous) { + public void apply(Map> values, Settings current, Settings previous, Logger logger) { for (Map.Entry> entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -310,7 +307,7 @@ public synchronized void addAffixGroupUpdateConsumer(List affixUpdaters = new ArrayList<>(settings.size()); for (Setting.AffixSetting setting : settings) { ensureSettingIsRegistered(setting); - affixUpdaters.add(setting.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {})); + affixUpdaters.add(setting.newAffixUpdater((a,b)-> {}, (a,b)-> {})); } addSettingsUpdater(new SettingUpdater>() { @@ -324,8 +321,8 @@ public boolean hasChanged(Settings current, Settings previous) { public Map getValue(Settings current, Settings previous) { Set namespaces = new HashSet<>(); for (Setting.AffixSetting setting : settings) { - SettingUpdater affixUpdaterA = setting.newAffixUpdater((k, v) -> namespaces.add(k), logger, (a, b) ->{}); - affixUpdaterA.apply(current, previous); + SettingUpdater affixUpdaterA = setting.newAffixUpdater((k, v) -> namespaces.add(k), (a, b) ->{}); + affixUpdaterA.apply(current, previous, logger); } Map namespaceToSettings = new HashMap<>(namespaces.size()); for (String namespace : namespaces) { @@ -339,7 +336,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(Map values, Settings current, Settings previous) { + public void apply(Map values, Settings current, Settings previous, Logger logger) { for (Map.Entry entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -365,7 +362,7 @@ public synchronized void addAffixMapUpdateConsumer(Setting.AffixSetting s if (setting != registeredSetting) { throw new IllegalArgumentException("Setting is not registered for key [" + setting.getKey() + "]"); } - addSettingsUpdater(setting.newAffixMapUpdater(consumer, logger, validator)); + addSettingsUpdater(setting.newAffixMapUpdater(consumer, validator)); } synchronized void addSettingsUpdater(SettingUpdater updater) { @@ -397,7 +394,7 @@ public synchronized void addSettingsUpdateConsumer(Setting a, Setting< if (b != get(b.getKey())) { throw new IllegalArgumentException("Setting is not registered for key [" + b.getKey() + "]"); } - addSettingsUpdater(Setting.compoundUpdater(consumer, validator, a, b, logger)); + addSettingsUpdater(Setting.compoundUpdater(consumer, validator, a, b)); } /** @@ -587,30 +584,30 @@ public interface SettingUpdater { /** * Applies the given value to the updater. This methods will actually run the update. */ - void apply(T value, Settings current, Settings previous); + void apply(T value, Settings current, Settings previous, Logger logger); /** * Updates this updaters value if it has changed. * @return true iff the value has been updated. */ - default boolean apply(Settings current, Settings previous) { + default boolean apply(Settings current, Settings previous, Logger logger) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - apply(value, current, previous); + apply(value, current, previous, logger); return true; } return false; } /** - * Returns a callable runnable that calls {@link #apply(Object, Settings, Settings)} if the settings + * Returns a callable runnable that calls {@link #apply(Object, Settings, Settings, Logger)} if the settings * actually changed. This allows to defer the update to a later point in time while keeping type safety. * If the value didn't change the returned runnable is a noop. */ - default Runnable updater(Settings current, Settings previous) { + default Runnable updater(Settings current, Settings previous, Logger logger) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - return () -> { apply(value, current, previous);}; + return () -> { apply(value, current, previous, logger);}; } return () -> {}; } diff --git a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java index cb1de5c5982f1..18c15bb5ee52d 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java @@ -19,6 +19,7 @@ package org.elasticsearch.common.settings; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.elasticsearch.action.admin.cluster.configuration.TransportAddVotingConfigExclusionsAction; import org.elasticsearch.action.admin.indices.close.TransportCloseIndexAction; import org.elasticsearch.action.search.TransportSearchAction; @@ -124,7 +125,7 @@ public ClusterSettings(final Settings nodeSettings, final Set> settin } public ClusterSettings(final Settings nodeSettings, final Set> settingsSet, final Set> settingUpgraders) { - super(nodeSettings, settingsSet, settingUpgraders, Property.NodeScope, "cluster"); + super(nodeSettings, settingsSet, settingUpgraders, Property.NodeScope); addSettingsUpdater(new LoggingSettingUpdater(nodeSettings)); } @@ -158,7 +159,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous) { + public void apply(Settings value, Settings current, Settings previous, Logger logger) { for (String key : value.keySet()) { assert loggerPredicate.test(key); String component = key.substring("logger.".length()); diff --git a/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java index b0d8fb2ea0566..81c1ed7d1d249 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java @@ -182,15 +182,15 @@ public final class IndexScopedSettings extends AbstractScopedSettings { public static final IndexScopedSettings DEFAULT_SCOPED_SETTINGS = new IndexScopedSettings(Settings.EMPTY, BUILT_IN_INDEX_SETTINGS); public IndexScopedSettings(Settings settings, Set> settingsSet) { - super(settings, settingsSet, Collections.emptySet(), Property.IndexScope, "indexScopedSettings"); + super(settings, settingsSet, Collections.emptySet(), Property.IndexScope); } public IndexScopedSettings(Settings settings, Set> settingsSet, String prefix) { - super(settings, settingsSet, Collections.emptySet(), Property.IndexScope, prefix); + super(settings, settingsSet, Collections.emptySet(), Property.IndexScope); } private IndexScopedSettings(Settings settings, IndexScopedSettings other, IndexMetaData metaData) { - super(settings, metaData.getSettings(), other, metaData.getIndex().getName()); + super(settings, metaData.getSettings(), other); } public IndexScopedSettings copy(Settings settings, IndexMetaData metaData) { diff --git a/server/src/main/java/org/elasticsearch/common/settings/Setting.java b/server/src/main/java/org/elasticsearch/common/settings/Setting.java index 2e6bfdc635cd2..7bae13b87ee4b 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/Setting.java +++ b/server/src/main/java/org/elasticsearch/common/settings/Setting.java @@ -575,17 +575,17 @@ public Set> getSettingsDependencies(String key) { /** * Build a new updater with a noop validator. */ - final AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger logger) { - return newUpdater(consumer, logger, (s) -> {}); + final AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer) { + return newUpdater(consumer, (s) -> {}); } /** * Build the updater responsible for validating new values, logging the new * value, and eventually setting the value where it belongs. */ - AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger logger, Consumer validator) { + AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Consumer validator) { if (isDynamic()) { - return new Updater(consumer, logger, validator); + return new Updater(consumer, validator); } else { throw new IllegalStateException("setting [" + getKey() + "] is not dynamic"); } @@ -596,9 +596,9 @@ AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger * See {@link AbstractScopedSettings#addSettingsUpdateConsumer(Setting, Setting, BiConsumer)} and its usage for details. */ static AbstractScopedSettings.SettingUpdater> compoundUpdater(final BiConsumer consumer, - final BiConsumer validator, final Setting aSetting, final Setting bSetting, Logger logger) { - final AbstractScopedSettings.SettingUpdater aSettingUpdater = aSetting.newUpdater(null, logger); - final AbstractScopedSettings.SettingUpdater bSettingUpdater = bSetting.newUpdater(null, logger); + final BiConsumer validator, final Setting aSetting, final Setting bSetting) { + final AbstractScopedSettings.SettingUpdater aSettingUpdater = aSetting.newUpdater(null); + final AbstractScopedSettings.SettingUpdater bSettingUpdater = bSetting.newUpdater(null); return new AbstractScopedSettings.SettingUpdater>() { @Override public boolean hasChanged(Settings current, Settings previous) { @@ -614,7 +614,7 @@ public Tuple getValue(Settings current, Settings previous) { } @Override - public void apply(Tuple value, Settings current, Settings previous) { + public void apply(Tuple value, Settings current, Settings previous, Logger logger) { if (aSettingUpdater.hasChanged(current, previous)) { logSettingUpdate(aSetting, current, previous, logger); } @@ -660,7 +660,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous) { + public void apply(Settings value, Settings current, Settings previous, Logger logger) { consumer.accept(value); } @@ -703,7 +703,7 @@ public Set> getSettingsDependencies(String settingsKey) { } AbstractScopedSettings.SettingUpdater, T>> newAffixUpdater( - BiConsumer consumer, Logger logger, BiConsumer validator) { + BiConsumer consumer, BiConsumer validator) { return new AbstractScopedSettings.SettingUpdater, T>>() { @Override @@ -719,7 +719,7 @@ public Map, T> getValue(Settings curren String namespace = key.getNamespace(aKey); Setting concreteSetting = getConcreteSetting(namespace, aKey); AbstractScopedSettings.SettingUpdater updater = - concreteSetting.newUpdater((v) -> consumer.accept(namespace, v), logger, + concreteSetting.newUpdater((v) -> consumer.accept(namespace, v), (v) -> validator.accept(namespace, v)); if (updater.hasChanged(current, previous)) { // only the ones that have changed otherwise we might get too many updates @@ -732,15 +732,16 @@ public Map, T> getValue(Settings curren } @Override - public void apply(Map, T> value, Settings current, Settings previous) { + public void apply(Map, T> value, Settings current, + Settings previous, Logger logger) { for (Map.Entry, T> entry : value.entrySet()) { - entry.getKey().apply(entry.getValue(), current, previous); + entry.getKey().apply(entry.getValue(), current, previous, logger); } } }; } - AbstractScopedSettings.SettingUpdater> newAffixMapUpdater(Consumer> consumer, Logger logger, + AbstractScopedSettings.SettingUpdater> newAffixMapUpdater(Consumer> consumer, BiConsumer validator) { return new AbstractScopedSettings.SettingUpdater>() { @@ -757,7 +758,7 @@ public Map getValue(Settings current, Settings previous) { String namespace = key.getNamespace(aKey); Setting concreteSetting = getConcreteSetting(namespace, aKey); AbstractScopedSettings.SettingUpdater updater = - concreteSetting.newUpdater((v) -> {}, logger, (v) -> validator.accept(namespace, v)); + concreteSetting.newUpdater((v) -> {}, (v) -> validator.accept(namespace, v)); if (updater.hasChanged(current, previous)) { // only the ones that have changed otherwise we might get too many updates // the hasChanged above checks only if there are any changes @@ -769,7 +770,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(Map value, Settings current, Settings previous) { + public void apply(Map value, Settings current, Settings previous, Logger logger) { consumer.accept(value); } }; @@ -964,8 +965,7 @@ public void diff(Settings.Builder builder, Settings source, Settings defaultSett } @Override - public AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger logger, - Consumer validator) { + public AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Consumer validator) { if (isDynamic() == false) { throw new IllegalStateException("setting [" + getKey() + "] is not dynamic"); } @@ -994,7 +994,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous) { + public void apply(Settings value, Settings current, Settings previous, Logger logger) { Setting.logSettingUpdate(GroupSetting.this, current, previous, logger); consumer.accept(value); } @@ -1009,12 +1009,10 @@ public String toString() { private final class Updater implements AbstractScopedSettings.SettingUpdater { private final Consumer consumer; - private final Logger logger; private final Consumer accept; - Updater(Consumer consumer, Logger logger, Consumer accept) { + Updater(Consumer consumer, Consumer accept) { this.consumer = consumer; - this.logger = logger; this.accept = accept; } @@ -1052,7 +1050,7 @@ public T getValue(Settings current, Settings previous) { } @Override - public void apply(T value, Settings current, Settings previous) { + public void apply(T value, Settings current, Settings previous, Logger logger) { logSettingUpdate(Setting.this, current, previous, logger); consumer.accept(value); } diff --git a/server/src/main/java/org/elasticsearch/index/IndexSettings.java b/server/src/main/java/org/elasticsearch/index/IndexSettings.java index a1994d65c8d73..2cbd7f6b4e4a5 100644 --- a/server/src/main/java/org/elasticsearch/index/IndexSettings.java +++ b/server/src/main/java/org/elasticsearch/index/IndexSettings.java @@ -612,6 +612,13 @@ private void setRefreshInterval(TimeValue timeValue) { */ public Settings getSettings() { return settings; } + /** + * Returns the logger + */ + public Logger getLogger() { + return logger; + } + /** * Returns the index this settings object belongs to */ @@ -702,7 +709,7 @@ public synchronized boolean updateIndexMetaData(IndexMetaData indexMetaData) { // nothing to update, same settings return false; } - scopedSettings.applySettings(newSettings); + scopedSettings.applySettings(newSettings, logger); this.settings = newIndexSettings; return true; } diff --git a/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java b/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java index 39c5920f7d9d6..e2332e7bfd09f 100644 --- a/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java +++ b/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java @@ -181,11 +181,11 @@ public void testUpdate() { assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(value)); Settings newSettings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), !value).build(); - clusterSettings.applySettings(newSettings); + clusterSettings.applySettings(newSettings, logger); assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(!value)); newSettings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), "logs-*").build(); - clusterSettings.applySettings(newSettings); + clusterSettings.applySettings(newSettings, logger); assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(true)); assertThat(autoCreateIndex.getAutoCreate().getExpressions().size(), equalTo(1)); assertThat(autoCreateIndex.getAutoCreate().getExpressions().get(0).v1(), equalTo("logs-*")); diff --git a/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java b/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java index df73a2542e6c2..ff322feb1cf51 100644 --- a/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java @@ -62,7 +62,7 @@ public void testSettingCanBeUpdated() { createService(Settings.builder().put(NO_MASTER_BLOCK_SETTING.getKey(), "all").build()); assertThat(noMasterBlockService.getNoMasterBlock(), sameInstance(NO_MASTER_BLOCK_ALL)); - clusterSettings.applySettings(Settings.builder().put(NO_MASTER_BLOCK_SETTING.getKey(), "write").build()); + clusterSettings.applySettings(Settings.builder().put(NO_MASTER_BLOCK_SETTING.getKey(), "write").build(), logger); assertThat(noMasterBlockService.getNoMasterBlock(), sameInstance(NO_MASTER_BLOCK_WRITES)); } } diff --git a/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java b/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java index a1d12d98398ca..562141c3c4ca3 100644 --- a/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java @@ -225,7 +225,7 @@ public void testDynamicSetting() { assertThat(reconfigurator.reconfigure(twoNodes, retired(), randomFrom(twoNodes), initialConfig), equalTo(conf("a", "b", "c"))); // update to "false" - clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "false").build()); + clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "false").build(), logger); assertThat(reconfigurator.reconfigure(twoNodes, retired(), randomFrom(twoNodes), initialConfig), sameInstance(initialConfig)); // no quorum assertThat(reconfigurator.reconfigure(threeNodes, retired(), randomFrom(threeNodes), initialConfig), @@ -234,10 +234,10 @@ public void testDynamicSetting() { equalTo(conf("a", "b", "c", "e"))); // explicitly set to "true" - clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "true").build()); + clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "true").build(), logger); assertThat(reconfigurator.reconfigure(twoNodes, retired(), randomFrom(twoNodes), initialConfig), equalTo(conf("a", "b", "c"))); - expectThrows(IllegalArgumentException.class, () -> - clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "blah").build())); + expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings( + Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "blah").build(), logger)); } } diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java index 81ccdc35b248e..54fd011823157 100644 --- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java @@ -256,7 +256,7 @@ public void testPersistedSettings() { settings.put(BalancedShardsAllocator.THRESHOLD_SETTING.getKey(), 2.0); settings.put(ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(), ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()); - service.applySettings(settings.build()); + service.applySettings(settings.build(), logger); assertThat(allocator.getIndexBalance(), Matchers.equalTo(0.2f)); assertThat(allocator.getShardBalance(), Matchers.equalTo(0.3f)); assertThat(allocator.getThreshold(), Matchers.equalTo(2.0f)); @@ -265,7 +265,7 @@ public void testPersistedSettings() { settings.put(BalancedShardsAllocator.INDEX_BALANCE_FACTOR_SETTING.getKey(), 0.5); settings.put(BalancedShardsAllocator.SHARD_BALANCE_FACTOR_SETTING.getKey(), 0.1); settings.put(BalancedShardsAllocator.THRESHOLD_SETTING.getKey(), 3.0); - service.applySettings(settings.build()); + service.applySettings(settings.build(), logger); assertThat(allocator.getIndexBalance(), Matchers.equalTo(0.5f)); assertThat(allocator.getShardBalance(), Matchers.equalTo(0.1f)); assertThat(allocator.getThreshold(), Matchers.equalTo(3.0f)); diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java index 5bbd3ab33ce74..99d76ec84345a 100644 --- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java @@ -59,7 +59,7 @@ public void testUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "250mb") .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_REROUTE_INTERVAL_SETTING.getKey(), "30s") .build(); - nss.applySettings(newSettings); + nss.applySettings(newSettings, logger); assertEquals(ByteSizeValue.parseBytesSizeValue("500mb", "test"), diskThresholdSettings.getFreeBytesThresholdHigh()); assertEquals(0.0D, diskThresholdSettings.getFreeDiskThresholdHigh(), 0.0D); @@ -91,7 +91,8 @@ public void testInvalidLowHighPercentageUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), "80%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, + () -> clusterSettings.applySettings(newSettings, logger)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [90%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -110,7 +111,8 @@ public void testInvalidHighFloodPercentageUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "55%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, + () -> clusterSettings.applySettings(newSettings, logger)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [50%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -129,7 +131,8 @@ public void testInvalidLowHighBytesUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "250m") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, + () -> clusterSettings.applySettings(newSettings, logger)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [500m]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -148,7 +151,8 @@ public void testInvalidHighFloodBytesUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "750m") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, + () -> clusterSettings.applySettings(newSettings, logger)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [500m]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -167,7 +171,8 @@ public void testIncompatibleThresholdUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "95%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, + () -> clusterSettings.applySettings(newSettings, logger)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [90%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -193,7 +198,8 @@ public void testInvalidHighDiskThreshold() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), "75%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, + () -> clusterSettings.applySettings(newSettings, logger)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.high] from [90%] to [75%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java index c342443ad707b..75eea9519f7ce 100644 --- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java @@ -221,7 +221,7 @@ public void testEnableClusterBalance() { .put(EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), allowedOnes).build()))).build(); } - clusterSettings.applySettings(clusterState.metaData().settings()); + clusterSettings.applySettings(clusterState.metaData().settings(), logger); clusterState = strategy.reroute(clusterState, "reroute"); assertThat("expected 6 shards to be started 2 to relocate useClusterSettings: " + useClusterSetting, clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(6)); @@ -312,7 +312,7 @@ public void testEnableClusterBalanceNoReplicas() { .put(EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), randomBoolean() ? Rebalance.PRIMARIES : Rebalance.ALL).build()))).build(); } - clusterSettings.applySettings(clusterState.metaData().settings()); + clusterSettings.applySettings(clusterState.metaData().settings(), logger); clusterState = strategy.reroute(clusterState, "reroute"); assertThat("expected 4 primaries to be started and 2 to relocate useClusterSettings: " + useClusterSetting, clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(4)); diff --git a/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java b/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java index 6c0f6b0751a65..238ca666758ea 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java @@ -170,7 +170,7 @@ public void testAddConsumer() { } assertEquals(0, consumer.get()); assertEquals(0, consumer2.get()); - service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build()); + service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build(), logger); assertEquals(2, consumer.get()); assertEquals(0, consumer2.get()); } @@ -251,7 +251,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group2), "18", "19", "20") - .build()); + .build(), logger); assertEquals(2, results.get(group1).v2().intValue()); assertEquals(7, results.get(group2).v2().intValue()); assertEquals(Arrays.asList(16, 17), results.get(group1).v1()); @@ -265,7 +265,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putNull(listBuilder.apply(group2)) // removed - .build()); + .build(), logger); assertNull(group1 + " wasn't changed", results.get(group1)); assertEquals(1, results.get(group2).v1().size()); @@ -279,7 +279,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") // added - .build()); + .build(), logger); assertNull(group1 + " wasn't changed", results.get(group1)); assertNull(group2 + " wasn't changed", results.get(group2)); @@ -294,7 +294,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") - .build()); + .build(), logger); assertNull(group2 + " wasn't changed", results.get(group2)); assertNull(group3 + " wasn't changed", results.get(group3)); @@ -310,7 +310,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1)) // modified to trip validator .putList(listBuilder.apply(group3), "5", "6") - .build()) + .build(), logger) ); assertEquals("boom", iae.getMessage()); assertEquals(0, results.size()); @@ -340,7 +340,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group2), "18", "19", "20") - .build()); + .build(), logger); Settings groupOneSettings = results.get(group1); Settings groupTwoSettings = results.get(group2); assertEquals(2, intSetting.getConcreteSettingForNamespace(group1).get(groupOneSettings).intValue()); @@ -358,7 +358,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putNull(listBuilder.apply(group2)) // removed - .build()); + .build(), logger); assertNull(group1 + " wasn't changed", results.get(group1)); groupTwoSettings = results.get(group2); @@ -373,7 +373,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") // added - .build()); + .build(), logger); assertNull(group1 + " wasn't changed", results.get(group1)); assertNull(group2 + " wasn't changed", results.get(group2)); @@ -389,7 +389,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") - .build()); + .build(), logger); assertNull(group2 + " wasn't changed", results.get(group2)); assertNull(group3 + " wasn't changed", results.get(group3)); @@ -422,7 +422,7 @@ public void testAddConsumerAffix() { .put("foo.test_1.bar", 7) .putList("foo.test_list.list", "16", "17") .putList("foo.test_list_1.list", "18", "19", "20") - .build()); + .build(), logger); assertEquals(2, intResults.get("test").intValue()); assertEquals(7, intResults.get("test_1").intValue()); assertEquals(Arrays.asList(16, 17), listResults.get("test_list")); @@ -438,7 +438,7 @@ public void testAddConsumerAffix() { .put("foo.test_1.bar", 8) .putList("foo.test_list.list", "16", "17") .putNull("foo.test_list_1.list") - .build()); + .build(), logger); assertNull("test wasn't changed", intResults.get("test")); assertEquals(8, intResults.get("test_1").intValue()); assertNull("test_list wasn't changed", listResults.get("test_list")); @@ -473,7 +473,7 @@ public void testAddConsumerAffixMap() { .put("foo.test_1.bar", 7) .putList("foo.test_list.list", "16", "17") .putList("foo.test_list_1.list", "18", "19", "20") - .build()); + .build(), logger); assertEquals(2, intResults.get("test").intValue()); assertEquals(7, intResults.get("test_1").intValue()); assertEquals(Arrays.asList(16, 17), listResults.get("test_list")); @@ -486,7 +486,7 @@ public void testAddConsumerAffixMap() { .put("foo.test_1.bar", 7) .putList("foo.test_list.list", "16", "17") .putList("foo.test_list_1.list", "18", "19", "20") - .build()); + .build(), logger); assertEquals(2, intResults.get("test").intValue()); assertEquals(7, intResults.get("test_1").intValue()); @@ -503,7 +503,7 @@ public void testAddConsumerAffixMap() { .put("foo.test_1.bar", 8) .putList("foo.test_list.list", "16", "17") .putNull("foo.test_list_1.list") - .build()); + .build(), logger); assertNull("test wasn't changed", intResults.get("test")); assertEquals(8, intResults.get("test_1").intValue()); assertNull("test_list wasn't changed", listResults.get("test_list")); @@ -529,14 +529,14 @@ public void testAffixMapConsumerNotCalledWithNull() { assertEquals(0, affixResults.size()); service.applySettings(Settings.builder() .put("eggplant._name", 2) - .build()); + .build(), logger); assertThat(affixResults.size(), equalTo(1)); assertThat(affixResults.get("_name"), equalTo(2)); service.applySettings(Settings.builder() .put("eggplant._name", 2) .put("other.thing", 3) - .build()); + .build(), logger); assertThat(affixResults.get("_name"), equalTo(2)); } @@ -563,7 +563,7 @@ public void testApply() { assertEquals(0, aC.get()); assertEquals(0, bC.get()); try { - service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", -15).build()); + service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", -15).build(), logger); fail("invalid value"); } catch (IllegalArgumentException ex) { assertEquals("illegal value can't update [foo.bar.baz] from [1] to [-15]", ex.getMessage()); @@ -589,7 +589,7 @@ public void testApply() { assertEquals(0, aC.get()); assertEquals(0, bC.get()); - service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build()); + service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build(), logger); assertEquals(2, consumer.get()); assertEquals(15, consumer2.get()); assertEquals(2, aC.get()); @@ -752,7 +752,7 @@ public void testUpdateTracer() { AtomicReference> ref = new AtomicReference<>(); settings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, ref::set); settings.applySettings(Settings.builder() - .putList("transport.tracer.include", "internal:index/shard/recovery/*", "internal:gateway/local*").build()); + .putList("transport.tracer.include", "internal:index/shard/recovery/*", "internal:gateway/local*").build(), logger); assertNotNull(ref.get().size()); assertEquals(ref.get().size(), 2); assertTrue(ref.get().contains("internal:index/shard/recovery/*")); @@ -912,13 +912,13 @@ public void testLoggingUpdates() { () -> settings.validate(Settings.builder().put("logger._root", "boom").build(), false)); assertEquals("Unknown level constant [BOOM].", ex.getMessage()); assertEquals(level, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().put("logger._root", "TRACE").build()); + settings.applySettings(Settings.builder().put("logger._root", "TRACE").build(), logger); assertEquals(Level.TRACE, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().build()); + settings.applySettings(Settings.builder().build(), logger); assertEquals(property, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().put("logger.test", "TRACE").build()); + settings.applySettings(Settings.builder().put("logger.test", "TRACE").build(), logger); assertEquals(Level.TRACE, LogManager.getLogger("test").getLevel()); - settings.applySettings(Settings.builder().build()); + settings.applySettings(Settings.builder().build(), logger); assertEquals(property, LogManager.getLogger("test").getLevel()); } finally { Loggers.setLevel(LogManager.getRootLogger(), level); @@ -932,9 +932,9 @@ public void testFallbackToLoggerLevel() { ClusterSettings settings = new ClusterSettings(Settings.builder().put("logger.level", "ERROR").build(), ClusterSettings.BUILT_IN_CLUSTER_SETTINGS); assertEquals(level, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().put("logger._root", "TRACE").build()); + settings.applySettings(Settings.builder().put("logger._root", "TRACE").build(), logger); assertEquals(Level.TRACE, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().build()); // here we fall back to 'logger.level' which is our default. + settings.applySettings(Settings.builder().build(), logger); // here we fall back to 'logger.level' which is our default. assertEquals(Level.ERROR, LogManager.getRootLogger().getLevel()); } finally { Loggers.setLevel(LogManager.getRootLogger(), level); diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java index d6c97f4aaeb55..dc967400fb694 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java @@ -18,7 +18,6 @@ */ package org.elasticsearch.common.settings; -import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.core.LogEvent; import org.apache.logging.log4j.core.appender.AbstractAppender; import org.apache.logging.log4j.core.filter.RegexFilter; @@ -129,18 +128,18 @@ public void testByteSizeSettingValidation() { final ByteSizeValue byteSizeValue = byteSizeValueSetting.get(Settings.EMPTY); assertThat(byteSizeValue.getBytes(), equalTo(2048L)); AtomicReference value = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = byteSizeValueSetting.newUpdater(value::set, logger); + ClusterSettings.SettingUpdater settingUpdater = byteSizeValueSetting.newUpdater(value::set); final IllegalArgumentException e = expectThrows( IllegalArgumentException.class, - () -> settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY)); + () -> settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY, logger)); assertThat(e, hasToString(containsString("illegal value can't update [a.byte.size] from [2048b] to [12]"))); assertNotNull(e.getCause()); assertThat(e.getCause(), instanceOf(IllegalArgumentException.class)); final IllegalArgumentException cause = (IllegalArgumentException) e.getCause(); final String expected = "failed to parse setting [a.byte.size] with value [12] as a size in bytes: unit is missing or unrecognized"; assertThat(cause, hasToString(containsString(expected))); - assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY)); + assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY, logger)); assertThat(value.get(), equalTo(new ByteSizeValue(12))); } @@ -166,9 +165,9 @@ public void testMemorySize() { assertEquals(memorySizeValue.getBytes(), JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.25, 1.0); AtomicReference value = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = memorySizeValueSetting.newUpdater(value::set, logger); + ClusterSettings.SettingUpdater settingUpdater = memorySizeValueSetting.newUpdater(value::set); try { - settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY); + settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY, logger); fail("no unit"); } catch (IllegalArgumentException ex) { assertThat(ex, hasToString(containsString("illegal value can't update [a.byte.size] from [25%] to [12]"))); @@ -180,28 +179,28 @@ public void testMemorySize() { assertThat(cause, hasToString(containsString(expected))); } - assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY)); + assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY, logger)); assertEquals(new ByteSizeValue(12), value.get()); - assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "20%").build(), Settings.EMPTY)); + assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "20%").build(), Settings.EMPTY, logger)); assertEquals(new ByteSizeValue((int) (JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.2)), value.get()); } public void testSimpleUpdate() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope); AtomicReference atomicBoolean = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set, logger); + ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set); Settings build = Settings.builder().put("foo.bar", false).build(); - settingUpdater.apply(build, Settings.EMPTY); + settingUpdater.apply(build, Settings.EMPTY, logger); assertNull(atomicBoolean.get()); build = Settings.builder().put("foo.bar", true).build(); - settingUpdater.apply(build, Settings.EMPTY); + settingUpdater.apply(build, Settings.EMPTY, logger); assertTrue(atomicBoolean.get()); // try update bogus value build = Settings.builder().put("foo.bar", "I am not a boolean").build(); try { - settingUpdater.apply(build, Settings.EMPTY); + settingUpdater.apply(build, Settings.EMPTY, logger); fail("not a boolean"); } catch (IllegalArgumentException ex) { assertThat(ex, hasToString(containsString("illegal value can't update [foo.bar] from [false] to [I am not a boolean]"))); @@ -216,11 +215,12 @@ public void testSimpleUpdate() { public void testSimpleUpdateOfFilteredSetting() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.Filtered); AtomicReference atomicBoolean = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set, logger); + ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set); // try update bogus value Settings build = Settings.builder().put("foo.bar", "I am not a boolean").build(); - IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(build, Settings.EMPTY)); + IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, + () -> settingUpdater.apply(build, Settings.EMPTY, logger)); assertThat(ex, hasToString(equalTo("java.lang.IllegalArgumentException: illegal value can't update [foo.bar]"))); assertNull(ex.getCause()); } @@ -378,7 +378,7 @@ public void testUpdateNotDynamic() { assertFalse(booleanSetting.isGroupSetting()); AtomicReference atomicBoolean = new AtomicReference<>(null); try { - booleanSetting.newUpdater(atomicBoolean::set, logger); + booleanSetting.newUpdater(atomicBoolean::set); fail("not dynamic"); } catch (IllegalStateException ex) { assertEquals("setting [foo.bar] is not dynamic", ex.getMessage()); @@ -389,8 +389,8 @@ public void testUpdaterIsIsolated() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope); AtomicReference ab1 = new AtomicReference<>(null); AtomicReference ab2 = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(ab1::set, logger); - settingUpdater.apply(Settings.builder().put("foo.bar", true).build(), Settings.EMPTY); + ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(ab1::set); + settingUpdater.apply(Settings.builder().put("foo.bar", true).build(), Settings.EMPTY, logger); assertTrue(ab1.get()); assertNull(ab2.get()); } @@ -436,18 +436,18 @@ public void testComplexType() { assertFalse(setting.isGroupSetting()); ref.set(setting.get(Settings.EMPTY)); ComplexType type = ref.get(); - ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set, logger); - assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY)); + ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set); + assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY, logger)); assertSame("no update - type has not changed", type, ref.get()); // change from default - assertTrue(settingUpdater.apply(Settings.builder().put("foo.bar", "2").build(), Settings.EMPTY)); + assertTrue(settingUpdater.apply(Settings.builder().put("foo.bar", "2").build(), Settings.EMPTY, logger)); assertNotSame("update - type has changed", type, ref.get()); assertEquals("2", ref.get().foo); // change back to default... - assertTrue(settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "2").build())); + assertTrue(settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "2").build(), logger)); assertNotSame("update - type has changed", type, ref.get()); assertEquals("", ref.get().foo); } @@ -465,14 +465,14 @@ public void testGroups() { AtomicReference ref = new AtomicReference<>(null); Setting setting = Setting.groupSetting("foo.bar.", Property.Dynamic, Property.NodeScope); assertTrue(setting.isGroupSetting()); - ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set, logger); + ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set); Settings currentInput = Settings.builder() .put("foo.bar.1.value", "1") .put("foo.bar.2.value", "2") .put("foo.bar.3.value", "3").build(); Settings previousInput = Settings.EMPTY; - assertTrue(settingUpdater.apply(currentInput, previousInput)); + assertTrue(settingUpdater.apply(currentInput, previousInput, logger)); assertNotNull(ref.get()); Settings settings = ref.get(); Map asMap = settings.getAsGroups(); @@ -484,13 +484,13 @@ public void testGroups() { previousInput = currentInput; currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").put("foo.bar.3.value", "3").build(); Settings current = ref.get(); - assertFalse(settingUpdater.apply(currentInput, previousInput)); + assertFalse(settingUpdater.apply(currentInput, previousInput, logger)); assertSame(current, ref.get()); previousInput = currentInput; currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(); // now update and check that we got it - assertTrue(settingUpdater.apply(currentInput, previousInput)); + assertTrue(settingUpdater.apply(currentInput, previousInput, logger)); assertNotSame(current, ref.get()); asMap = ref.get().getAsGroups(); @@ -501,7 +501,7 @@ public void testGroups() { previousInput = currentInput; currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "4").build(); // now update and check that we got it - assertTrue(settingUpdater.apply(currentInput, previousInput)); + assertTrue(settingUpdater.apply(currentInput, previousInput, logger)); assertNotSame(current, ref.get()); asMap = ref.get().getAsGroups(); @@ -512,10 +512,10 @@ public void testGroups() { assertTrue(setting.match("foo.bar.baz")); assertFalse(setting.match("foo.baz.bar")); - ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set, logger,(s) -> assertFalse(true)); + ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set,(s) -> assertFalse(true)); try { predicateSettingUpdater.apply(Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(), - Settings.EMPTY); + Settings.EMPTY, logger); fail("not accepted"); } catch (IllegalArgumentException ex) { assertEquals(ex.getMessage(), "illegal value can't update [foo.bar.] from [{}] to [{\"1.value\":\"1\",\"2.value\":\"2\"}]"); @@ -526,10 +526,10 @@ public void testFilteredGroups() { AtomicReference ref = new AtomicReference<>(null); Setting setting = Setting.groupSetting("foo.bar.", Property.Filtered, Property.Dynamic); - ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set, logger, (s) -> assertFalse(true)); + ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set, (s) -> assertFalse(true)); IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> predicateSettingUpdater.apply(Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(), - Settings.EMPTY)); + Settings.EMPTY, logger)); assertEquals("illegal value can't update [foo.bar.]", ex.getMessage()); } @@ -564,27 +564,27 @@ public void testComposite() { Composite c = new Composite(); Setting a = Setting.intSetting("foo.int.bar.a", 1, Property.Dynamic, Property.NodeScope); Setting b = Setting.intSetting("foo.int.bar.b", 1, Property.Dynamic, Property.NodeScope); - ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b, logger); - assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY)); + ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b); + assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY, logger)); assertNull(c.a); assertNull(c.b); Settings build = Settings.builder().put("foo.int.bar.a", 2).build(); - assertTrue(settingUpdater.apply(build, Settings.EMPTY)); + assertTrue(settingUpdater.apply(build, Settings.EMPTY, logger)); assertEquals(2, c.a.intValue()); assertEquals(1, c.b.intValue()); Integer aValue = c.a; - assertFalse(settingUpdater.apply(build, build)); + assertFalse(settingUpdater.apply(build, build, logger)); assertSame(aValue, c.a); Settings previous = build; build = Settings.builder().put("foo.int.bar.a", 2).put("foo.int.bar.b", 5).build(); - assertTrue(settingUpdater.apply(build, previous)); + assertTrue(settingUpdater.apply(build, previous, logger)); assertEquals(2, c.a.intValue()); assertEquals(5, c.b.intValue()); // reset to default - assertTrue(settingUpdater.apply(Settings.EMPTY, build)); + assertTrue(settingUpdater.apply(Settings.EMPTY, build, logger)); assertEquals(1, c.a.intValue()); assertEquals(1, c.b.intValue()); @@ -594,31 +594,31 @@ public void testCompositeValidator() { Composite c = new Composite(); Setting a = Setting.intSetting("foo.int.bar.a", 1, Property.Dynamic, Property.NodeScope); Setting b = Setting.intSetting("foo.int.bar.b", 1, Property.Dynamic, Property.NodeScope); - ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b, logger); - assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY)); + ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b); + assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY, logger)); assertNull(c.a); assertNull(c.b); Settings build = Settings.builder().put("foo.int.bar.a", 2).build(); - assertTrue(settingUpdater.apply(build, Settings.EMPTY)); + assertTrue(settingUpdater.apply(build, Settings.EMPTY, logger)); assertEquals(2, c.a.intValue()); assertEquals(1, c.b.intValue()); Integer aValue = c.a; - assertFalse(settingUpdater.apply(build, build)); + assertFalse(settingUpdater.apply(build, build, logger)); assertSame(aValue, c.a); Settings previous = build; build = Settings.builder().put("foo.int.bar.a", 2).put("foo.int.bar.b", 5).build(); - assertTrue(settingUpdater.apply(build, previous)); + assertTrue(settingUpdater.apply(build, previous, logger)); assertEquals(2, c.a.intValue()); assertEquals(5, c.b.intValue()); Settings invalid = Settings.builder().put("foo.int.bar.a", -2).put("foo.int.bar.b", 5).build(); - IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(invalid, previous)); + IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(invalid, previous, logger)); assertThat(exc.getMessage(), equalTo("boom")); // reset to default - assertTrue(settingUpdater.apply(Settings.EMPTY, build)); + assertTrue(settingUpdater.apply(Settings.EMPTY, build, logger)); assertEquals(1, c.a.intValue()); assertEquals(1, c.b.intValue()); @@ -670,21 +670,22 @@ public void testListSettings() { assertTrue(listSetting.exists(builder.build())); AtomicReference> ref = new AtomicReference<>(); - AbstractScopedSettings.SettingUpdater> settingUpdater = listSetting.newUpdater(ref::set, logger); + AbstractScopedSettings.SettingUpdater> settingUpdater = listSetting.newUpdater(ref::set); assertTrue(settingUpdater.hasChanged(builder.build(), Settings.EMPTY)); - settingUpdater.apply(builder.build(), Settings.EMPTY); + settingUpdater.apply(builder.build(), Settings.EMPTY, logger); assertEquals(input.size(), ref.get().size()); assertArrayEquals(ref.get().toArray(new String[0]), input.toArray(new String[0])); - settingUpdater.apply(Settings.builder().putList("foo.bar", "123").build(), builder.build()); + settingUpdater.apply(Settings.builder().putList("foo.bar", "123").build(), builder.build(), logger); assertEquals(1, ref.get().size()); assertArrayEquals(ref.get().toArray(new String[0]), new String[] {"123"}); - settingUpdater.apply(Settings.builder().put("foo.bar", "1,2,3").build(), Settings.builder().putList("foo.bar", "123").build()); + settingUpdater.apply(Settings.builder().put("foo.bar", "1,2,3").build(), + Settings.builder().putList("foo.bar", "123").build(), logger); assertEquals(3, ref.get().size()); assertArrayEquals(ref.get().toArray(new String[0]), new String[] {"1", "2", "3"}); - settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "1,2,3").build()); + settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "1,2,3").build(), logger); assertEquals(1, ref.get().size()); assertEquals("foo,bar", ref.get().get(0)); @@ -979,7 +980,7 @@ public void testSettingsGroupUpdater() { Settings current = Settings.builder().put("prefix.foo", 123).put("prefix.same", 5555).build(); Settings previous = Settings.builder().put("prefix.foo", 321).put("prefix.same", 5555).build(); - assertTrue(updater.apply(current, previous)); + assertTrue(updater.apply(current, previous, logger)); } public void testSettingsGroupUpdaterRemoval() { @@ -990,7 +991,7 @@ public void testSettingsGroupUpdaterRemoval() { Settings current = Settings.builder().put("prefix.same", 5555).build(); Settings previous = Settings.builder().put("prefix.foo", 321).put("prefix.same", 5555).build(); - assertTrue(updater.apply(current, previous)); + assertTrue(updater.apply(current, previous, logger)); } public void testSettingsGroupUpdaterWithAffixSetting() { @@ -1035,7 +1036,7 @@ public void testSettingsGroupUpdaterWithAffixSetting() { boolean expectedChange = removeAffixKeySetting || removePrefixKeySetting || changeAffixKeySetting || changePrefixKeySetting || removeAffixNamespace; - assertThat(updater.apply(currentSettingsBuilder.build(), previousSettingsBuilder.build()), is(expectedChange)); + assertThat(updater.apply(currentSettingsBuilder.build(), previousSettingsBuilder.build(), logger), is(expectedChange)); } public void testAffixNamespacesWithGroupSetting() { @@ -1097,7 +1098,7 @@ public void testAffixMapUpdateWithNullSettingValue() { final BiConsumer validator = (s1, s2) -> {}; // WHEN creating an affix updater - final SettingUpdater> updater = affixSetting.newAffixMapUpdater(consumer, logger, validator); + final SettingUpdater> updater = affixSetting.newAffixMapUpdater(consumer, validator); // THEN affix updater is always expected to have changed (even when defaults are omitted) assertTrue(updater.hasChanged(current, previous)); @@ -1129,16 +1130,16 @@ public void testLogSettingUpdate() throws Exception { .put(IndexSettings.INDEX_WARMER_ENABLED_SETTING.getKey(), false) .build()); IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY); - Logger logger = settings.getScopedSettings().logger; - MockAppender appender = new MockAppender("trace_appender"); + MockAppender appender = new MockAppender("logSettingUpdate"); appender.start(); - Loggers.addAppender(logger, appender); + Loggers.addAppender(settings.getLogger(), appender); settings.updateIndexMetaData(newIndexMeta("index1", Settings.builder().put(IndexSettings.INDEX_WARMER_ENABLED_SETTING.getKey(), "true").build())); assertThat(appender.lastMementoMessage().getFormattedMessage(), equalTo("updating [index.warmer.enabled] from [false] to [true]")); - assertThat(appender.getLoggerMaker(), equalTo("[index1]")); + assertThat(appender.getLoggerMaker(), equalTo(" [index1]")); + appender.stop(); } } diff --git a/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java b/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java index 65432466c61a1..a03a6412be6e1 100644 --- a/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java +++ b/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java @@ -490,7 +490,7 @@ public void testSlowLogging() throws WriteStateException, IllegalAccessException clusterSettings.applySettings(Settings.builder() .put(IncrementalClusterStateWriter.SLOW_WRITE_LOGGING_THRESHOLD.getKey(), writeDurationMillis.get() + "ms") - .build()); + .build(), logger); assertExpectedLogs(clusterState, incrementalClusterStateWriter, new MockLogAppender.SeenEventExpectation( "should see warning at reduced threshold", IncrementalClusterStateWriter.class.getCanonicalName(), diff --git a/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java b/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java index 93867f4aa4c77..1bbd0c03bdf99 100644 --- a/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java +++ b/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java @@ -3053,7 +3053,7 @@ public void testReadSnapshotConcurrently() throws IOException, InterruptedExcept expectThrows(AlreadyClosedException.class, () -> newShard.getEngine()); // no engine Thread thread = new Thread(() -> { latch.countDown(); - while(stop.get() == false){ + while(stop.get() == false) { try { Store.MetadataSnapshot readMeta = newShard.snapshotStoreMetadata(); assertEquals(0, storeFileMetaDatas.recoveryDiff(readMeta).different.size()); @@ -3332,17 +3332,17 @@ public void testIsSearchIdle() throws Exception { IndexScopedSettings scopedSettings = primary.indexSettings().getScopedSettings(); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.ZERO).build(); - scopedSettings.applySettings(settings); + scopedSettings.applySettings(settings, logger); assertTrue(primary.isSearchIdle()); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.timeValueMinutes(1)) .build(); - scopedSettings.applySettings(settings); + scopedSettings.applySettings(settings, logger); assertFalse(primary.isSearchIdle()); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.timeValueMillis(10)) .build(); - scopedSettings.applySettings(settings); + scopedSettings.applySettings(settings, logger); assertBusy(() -> assertTrue(primary.isSearchIdle())); do { @@ -3374,7 +3374,7 @@ public void testScheduledRefresh() throws Exception { assertTrue(primary.scheduledRefresh()); IndexScopedSettings scopedSettings = primary.indexSettings().getScopedSettings(); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.ZERO).build(); - scopedSettings.applySettings(settings); + scopedSettings.applySettings(settings, logger); assertFalse(primary.getEngine().refreshNeeded()); indexDoc(primary, "_doc", "1", "{\"foo\" : \"bar\"}"); @@ -3451,7 +3451,7 @@ public void testRefreshIsNeededWithRefreshListeners() throws IOException, Interr IndexScopedSettings scopedSettings = primary.indexSettings().getScopedSettings(); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.ZERO).build(); - scopedSettings.applySettings(settings); + scopedSettings.applySettings(settings, logger); doc = indexDoc(primary, "_doc", "2", "{\"foo\" : \"bar\"}"); CountDownLatch latch1 = new CountDownLatch(1); diff --git a/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java b/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java index 54e082098763e..d8081ef7fd50c 100644 --- a/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java +++ b/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java @@ -33,7 +33,7 @@ public class RecoverySettingsDynamicUpdateTests extends ESTestCase { public void testZeroBytesPerSecondIsNoRateLimit() { clusterSettings.applySettings(Settings.builder().put( - RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), 0).build()); + RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), 0).build(), logger); assertEquals(null, recoverySettings.rateLimiter()); } @@ -42,7 +42,7 @@ public void testRetryDelayStateSync() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_RETRY_DELAY_STATE_SYNC_SETTING.getKey(), duration, timeUnit - ).build()); + ).build(), logger); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.retryDelayStateSync()); } @@ -51,7 +51,7 @@ public void testRetryDelayNetwork() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_RETRY_DELAY_NETWORK_SETTING.getKey(), duration, timeUnit - ).build()); + ).build(), logger); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.retryDelayNetwork()); } @@ -60,7 +60,7 @@ public void testActivityTimeout() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_ACTIVITY_TIMEOUT_SETTING.getKey(), duration, timeUnit - ).build()); + ).build(), logger); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.activityTimeout()); } @@ -69,7 +69,7 @@ public void testInternalActionTimeout() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_INTERNAL_ACTION_TIMEOUT_SETTING.getKey(), duration, timeUnit - ).build()); + ).build(), logger); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.internalActionTimeout()); } @@ -78,7 +78,7 @@ public void testInternalLongActionTimeout() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_INTERNAL_LONG_ACTION_TIMEOUT_SETTING.getKey(), duration, timeUnit - ).build()); + ).build(), logger); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.internalActionLongTimeout()); } } diff --git a/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java b/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java index 2007c350b555b..f83a6de59d828 100644 --- a/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java +++ b/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java @@ -92,7 +92,7 @@ protected void updateSettings(final Settings settings) { ClusterSettings clusterSettings = clusterService.getClusterSettings(); Settings.Builder updated = Settings.builder(); clusterSettings.updateDynamicSettings(settings, updated, Settings.builder(), getTestClass().getName()); - clusterSettings.applySettings(updated.build()); + clusterSettings.applySettings(updated.build(), logger); } protected static ClusterState createClusterStateWithTasks(final int nbNodes, final int nbTasks) { diff --git a/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java b/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java index f49bb70dc7ffc..5cbf00283f7d5 100644 --- a/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java +++ b/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java @@ -326,12 +326,12 @@ public void testMaxSizeLimit() throws Exception { scriptService.compile(new Script(ScriptType.INLINE, "test", "10+10", Collections.emptyMap()), randomFrom(contexts.values())); }); assertEquals("exceeded max allowed inline script size in bytes [4] with size [5] for script [10+10]", iae.getMessage()); - clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 6).build()); + clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 6).build(), logger); scriptService.compile(new Script(ScriptType.INLINE, "test", "10+10", Collections.emptyMap()), randomFrom(contexts.values())); - clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 5).build()); + clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 5).build(), logger); scriptService.compile(new Script(ScriptType.INLINE, "test", "10+10", Collections.emptyMap()), randomFrom(contexts.values())); iae = expectThrows(IllegalArgumentException.class, () -> { - clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 2).build()); + clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 2).build(), logger); }); assertEquals("script.max_size_in_bytes cannot be set to [2], stored script [test1] exceeds the new value with a size of [3]", iae.getMessage()); diff --git a/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java b/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java index 4dddb0af9b4c4..579eda72a3d91 100644 --- a/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java +++ b/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java @@ -1059,7 +1059,7 @@ public String executor() { clusterSettingsA.applySettings(Settings.builder() .put(TransportSettings.TRACE_LOG_INCLUDE_SETTING.getKey(), includeSettings) .put(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.getKey(), excludeSettings) - .build()); + .build(), logger); MockLogAppender appender = new MockLogAppender(); try { diff --git a/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java b/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java index 711caf3a6468c..9afe95df0fd2a 100644 --- a/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java +++ b/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java @@ -248,7 +248,7 @@ Map initExporters(Settings settings) { .put("xpack.monitoring.exporters._name0.use_ingest", true) .put("xpack.monitoring.exporters._name1.use_ingest", false) .build(); - clusterSettings.applySettings(update); + clusterSettings.applySettings(update, logger); assertThat(settingsHolder.get(), notNullValue()); settings = settingsHolder.get(); logger.info(settings); diff --git a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java index 3a7eb2b26d85d..d5e123c2313bb 100644 --- a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java +++ b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authc/RealmSettingsTests.java @@ -317,7 +317,7 @@ private IllegalArgumentException assertError(String realmType, String realmName, private void validate(Settings settings) { final Set> settingsSet = new HashSet<>(InternalRealmsSettings.getSettings()); final AbstractScopedSettings validator = new AbstractScopedSettings(settings, settingsSet, Collections.emptySet(), - Setting.Property.NodeScope, "realm") { + Setting.Property.NodeScope) { }; validator.validate(settings, false); } diff --git a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java index e3777fc854599..91a7df83756a6 100644 --- a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java +++ b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java @@ -165,7 +165,7 @@ public void testThatProfilesAreUpdateable() throws Exception { .put("transport.profiles.client.xpack.security.filter.deny", "192.168.0.3").build(); Settings.Builder updatedSettingsBuilder = Settings.builder(); clusterSettings.updateDynamicSettings(newSettings, updatedSettingsBuilder, Settings.builder(), "test"); - clusterSettings.applySettings(updatedSettingsBuilder.build()); + clusterSettings.applySettings(updatedSettingsBuilder.build(), logger); assertAddressIsAllowed("127.0.0.1"); // when "localhost" is used, ES considers all local addresses see PatternRule#isLocalhost() assertAddressIsDenied(randomNonLocalIPv4Address()); diff --git a/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java b/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java index e83f9154c5459..902819d161554 100644 --- a/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java +++ b/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java @@ -718,7 +718,7 @@ public void testThatWhiteListReloadingWorks() throws Exception { assertThat(e.getMessage(), containsString("is not whitelisted")); Settings newSettings = Settings.builder().put(HttpSettings.HOSTS_WHITELIST.getKey(), getWebserverUri()).build(); - clusterSettings.applySettings(newSettings); + clusterSettings.applySettings(newSettings, logger); HttpResponse response = client.execute(request); assertThat(response.status(), is(200)); From f5364d3ba4ea7386c855bf25ad7f2e7243423c00 Mon Sep 17 00:00:00 2001 From: kewei03 Date: Wed, 11 Dec 2019 00:18:05 +0800 Subject: [PATCH 5/7] pass AbstractScopedSettings#logger by subclasses --- .../service/ClusterApplierService.java | 2 +- .../settings/AbstractScopedSettings.java | 56 ++++---- .../common/settings/ClusterSettings.java | 3 +- .../common/settings/IndexScopedSettings.java | 7 +- .../common/settings/Setting.java | 44 ++++--- .../elasticsearch/index/IndexSettings.java | 9 +- .../action/support/AutoCreateIndexTests.java | 4 +- .../NoMasterBlockServiceTests.java | 2 +- .../coordination/ReconfiguratorTests.java | 8 +- .../allocation/BalanceConfigurationTests.java | 4 +- .../DiskThresholdSettingsTests.java | 20 +-- .../decider/EnableAllocationTests.java | 4 +- .../common/settings/ScopedSettingsTests.java | 52 ++++---- .../common/settings/SettingTests.java | 123 +++++++++--------- .../IncrementalClusterStateWriterTests.java | 2 +- .../index/shard/IndexShardTests.java | 12 +- .../RecoverySettingsDynamicUpdateTests.java | 12 +- .../PersistentTasksDecidersTestCase.java | 2 +- .../script/ScriptServiceTests.java | 6 +- .../test/IndexSettingsModule.java | 5 +- .../AbstractSimpleTransportTestCase.java | 2 +- .../monitoring/exporter/ExportersTests.java | 2 +- .../transport/filter/IPFilterTests.java | 2 +- .../watcher/common/http/HttpClientTests.java | 2 +- 24 files changed, 186 insertions(+), 199 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java index eb629f2b5086a..574919f6751ab 100644 --- a/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java +++ b/server/src/main/java/org/elasticsearch/cluster/service/ClusterApplierService.java @@ -477,7 +477,7 @@ private void applyChanges(UpdateTask task, ClusterState previousClusterState, Cl logger.debug("applying settings from cluster state with version {}", newClusterState.version()); final Settings incomingSettings = clusterChangedEvent.state().metaData().settings(); try (Releasable ignored = stopWatch.timing("applying settings")) { - clusterSettings.applySettings(incomingSettings, logger); + clusterSettings.applySettings(incomingSettings); } } diff --git a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java index 39e0657638d64..1228cb7dbe55a 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java @@ -55,7 +55,7 @@ public abstract class AbstractScopedSettings { private static final Pattern GROUP_KEY_PATTERN = Pattern.compile("^(?:[-\\w]+[.])+$"); private static final Pattern AFFIX_KEY_PATTERN = Pattern.compile("^(?:[-\\w]+[.])+[*](?:[.][-\\w]+)+$"); - protected final Logger logger = LogManager.getLogger(this.getClass()); + private final Logger logger; private final Settings settings; private final List> settingUpdaters = new CopyOnWriteArrayList<>(); @@ -70,6 +70,7 @@ protected AbstractScopedSettings( final Set> settingsSet, final Set> settingUpgraders, final Setting.Property scope) { + this.logger = LogManager.getLogger(this.getClass()); this.settings = settings; this.lastSettingsApplied = Settings.EMPTY; @@ -110,7 +111,8 @@ protected void validateSettingKey(Setting setting) { } } - protected AbstractScopedSettings(Settings nodeSettings, Settings scopeSettings, AbstractScopedSettings other) { + protected AbstractScopedSettings(Settings nodeSettings, Settings scopeSettings, AbstractScopedSettings other, Logger logger) { + this.logger = logger; this.settings = nodeSettings; this.lastSettingsApplied = scopeSettings; this.scope = other.scope; @@ -136,6 +138,10 @@ static boolean isValidAffixKey(String key) { return AFFIX_KEY_PATTERN.matcher(key).matches(); } + public Logger getLogger() { + return logger; + } + public Setting.Property getScope() { return this.scope; } @@ -170,7 +176,7 @@ public synchronized Settings validateUpdate(Settings settings) { * @param newSettings the settings to apply * @return the unmerged applied settings */ - public synchronized Settings applySettings(Settings newSettings, Logger logger) { + public synchronized Settings applySettings(Settings newSettings) { if (lastSettingsApplied != null && newSettings.equals(lastSettingsApplied)) { // nothing changed in the settings, ignore return newSettings; @@ -181,7 +187,7 @@ public synchronized Settings applySettings(Settings newSettings, Logger logger) List applyRunnables = new ArrayList<>(); for (SettingUpdater settingUpdater : settingUpdaters) { try { - applyRunnables.add(settingUpdater.updater(current, previous, logger)); + applyRunnables.add(settingUpdater.updater(current, previous)); } catch (Exception ex) { logger.warn(() -> new ParameterizedMessage("failed to prepareCommit settings for [{}]", settingUpdater), ex); throw ex; @@ -209,7 +215,7 @@ public synchronized void addSettingsUpdateConsumer(Setting setting, Consu if (setting != get(setting.getKey())) { throw new IllegalArgumentException("Setting is not registered for key [" + setting.getKey() + "]"); } - addSettingsUpdater(setting.newUpdater(consumer, validator)); + addSettingsUpdater(setting.newUpdater(consumer, logger, validator)); } /** @@ -229,7 +235,7 @@ public synchronized void addSettingsUpdateConsumer(Consumer consumer, public synchronized void addAffixUpdateConsumer(Setting.AffixSetting setting, BiConsumer consumer, BiConsumer validator) { ensureSettingIsRegistered(setting); - addSettingsUpdater(setting.newAffixUpdater(consumer, validator)); + addSettingsUpdater(setting.newAffixUpdater(consumer, logger, validator)); } /** @@ -248,8 +254,8 @@ public synchronized void addAffixUpdateConsumer(Setting.AffixSetting se // down the road this would be nice to have! ensureSettingIsRegistered(settingA); ensureSettingIsRegistered(settingB); - SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater((a,b)-> {}, (a,b)-> {}); - SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater((a,b)-> {}, (a,b)-> {}); + SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {}); + SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {}); addSettingsUpdater(new SettingUpdater>>() { @@ -276,10 +282,10 @@ public Map> getValue(Settings current, Settings previous) { map.put(key, new Tuple<>(settingA.getConcreteSettingForNamespace(key).get(current), value)); } }; - SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater(aConsumer, (a,b) ->{}); - SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater(bConsumer, (a,b) ->{}); - affixUpdaterA.apply(current, previous, logger); - affixUpdaterB.apply(current, previous, logger); + SettingUpdater, A>> affixUpdaterA = settingA.newAffixUpdater(aConsumer, logger, (a,b) ->{}); + SettingUpdater, B>> affixUpdaterB = settingB.newAffixUpdater(bConsumer, logger, (a,b) ->{}); + affixUpdaterA.apply(current, previous); + affixUpdaterB.apply(current, previous); for (Map.Entry> entry : map.entrySet()) { validator.accept(entry.getKey(), entry.getValue()); } @@ -287,7 +293,7 @@ public Map> getValue(Settings current, Settings previous) { } @Override - public void apply(Map> values, Settings current, Settings previous, Logger logger) { + public void apply(Map> values, Settings current, Settings previous) { for (Map.Entry> entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -307,7 +313,7 @@ public synchronized void addAffixGroupUpdateConsumer(List affixUpdaters = new ArrayList<>(settings.size()); for (Setting.AffixSetting setting : settings) { ensureSettingIsRegistered(setting); - affixUpdaters.add(setting.newAffixUpdater((a,b)-> {}, (a,b)-> {})); + affixUpdaters.add(setting.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {})); } addSettingsUpdater(new SettingUpdater>() { @@ -321,8 +327,8 @@ public boolean hasChanged(Settings current, Settings previous) { public Map getValue(Settings current, Settings previous) { Set namespaces = new HashSet<>(); for (Setting.AffixSetting setting : settings) { - SettingUpdater affixUpdaterA = setting.newAffixUpdater((k, v) -> namespaces.add(k), (a, b) ->{}); - affixUpdaterA.apply(current, previous, logger); + SettingUpdater affixUpdaterA = setting.newAffixUpdater((k, v) -> namespaces.add(k), logger, (a, b) ->{}); + affixUpdaterA.apply(current, previous); } Map namespaceToSettings = new HashMap<>(namespaces.size()); for (String namespace : namespaces) { @@ -336,7 +342,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(Map values, Settings current, Settings previous, Logger logger) { + public void apply(Map values, Settings current, Settings previous) { for (Map.Entry entry : values.entrySet()) { consumer.accept(entry.getKey(), entry.getValue()); } @@ -362,7 +368,7 @@ public synchronized void addAffixMapUpdateConsumer(Setting.AffixSetting s if (setting != registeredSetting) { throw new IllegalArgumentException("Setting is not registered for key [" + setting.getKey() + "]"); } - addSettingsUpdater(setting.newAffixMapUpdater(consumer, validator)); + addSettingsUpdater(setting.newAffixMapUpdater(consumer, logger, validator)); } synchronized void addSettingsUpdater(SettingUpdater updater) { @@ -394,7 +400,7 @@ public synchronized void addSettingsUpdateConsumer(Setting a, Setting< if (b != get(b.getKey())) { throw new IllegalArgumentException("Setting is not registered for key [" + b.getKey() + "]"); } - addSettingsUpdater(Setting.compoundUpdater(consumer, validator, a, b)); + addSettingsUpdater(Setting.compoundUpdater(consumer, validator, a, b, logger)); } /** @@ -584,30 +590,30 @@ public interface SettingUpdater { /** * Applies the given value to the updater. This methods will actually run the update. */ - void apply(T value, Settings current, Settings previous, Logger logger); + void apply(T value, Settings current, Settings previous); /** * Updates this updaters value if it has changed. * @return true iff the value has been updated. */ - default boolean apply(Settings current, Settings previous, Logger logger) { + default boolean apply(Settings current, Settings previous) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - apply(value, current, previous, logger); + apply(value, current, previous); return true; } return false; } /** - * Returns a callable runnable that calls {@link #apply(Object, Settings, Settings, Logger)} if the settings + * Returns a callable runnable that calls {@link #apply(Object, Settings, Settings)} if the settings * actually changed. This allows to defer the update to a later point in time while keeping type safety. * If the value didn't change the returned runnable is a noop. */ - default Runnable updater(Settings current, Settings previous, Logger logger) { + default Runnable updater(Settings current, Settings previous) { if (hasChanged(current, previous)) { T value = getValue(current, previous); - return () -> { apply(value, current, previous, logger);}; + return () -> { apply(value, current, previous);}; } return () -> {}; } diff --git a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java index 18c15bb5ee52d..ef40f05a2f261 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java @@ -19,7 +19,6 @@ package org.elasticsearch.common.settings; import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import org.elasticsearch.action.admin.cluster.configuration.TransportAddVotingConfigExclusionsAction; import org.elasticsearch.action.admin.indices.close.TransportCloseIndexAction; import org.elasticsearch.action.search.TransportSearchAction; @@ -159,7 +158,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous, Logger logger) { + public void apply(Settings value, Settings current, Settings previous) { for (String key : value.keySet()) { assert loggerPredicate.test(key); String component = key.substring("logger.".length()); diff --git a/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java index 81c1ed7d1d249..e278f01002595 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/IndexScopedSettings.java @@ -24,6 +24,7 @@ import org.elasticsearch.cluster.routing.allocation.decider.EnableAllocationDecider; import org.elasticsearch.cluster.routing.allocation.decider.MaxRetryAllocationDecider; import org.elasticsearch.cluster.routing.allocation.decider.ShardsLimitAllocationDecider; +import org.elasticsearch.common.logging.Loggers; import org.elasticsearch.common.settings.Setting.Property; import org.elasticsearch.index.IndexModule; import org.elasticsearch.index.IndexSettings; @@ -185,12 +186,8 @@ public IndexScopedSettings(Settings settings, Set> settingsSet) { super(settings, settingsSet, Collections.emptySet(), Property.IndexScope); } - public IndexScopedSettings(Settings settings, Set> settingsSet, String prefix) { - super(settings, settingsSet, Collections.emptySet(), Property.IndexScope); - } - private IndexScopedSettings(Settings settings, IndexScopedSettings other, IndexMetaData metaData) { - super(settings, metaData.getSettings(), other); + super(settings, metaData.getSettings(), other, Loggers.getLogger(IndexScopedSettings.class, metaData.getIndex())); } public IndexScopedSettings copy(Settings settings, IndexMetaData metaData) { diff --git a/server/src/main/java/org/elasticsearch/common/settings/Setting.java b/server/src/main/java/org/elasticsearch/common/settings/Setting.java index 7bae13b87ee4b..2e6bfdc635cd2 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/Setting.java +++ b/server/src/main/java/org/elasticsearch/common/settings/Setting.java @@ -575,17 +575,17 @@ public Set> getSettingsDependencies(String key) { /** * Build a new updater with a noop validator. */ - final AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer) { - return newUpdater(consumer, (s) -> {}); + final AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger logger) { + return newUpdater(consumer, logger, (s) -> {}); } /** * Build the updater responsible for validating new values, logging the new * value, and eventually setting the value where it belongs. */ - AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Consumer validator) { + AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger logger, Consumer validator) { if (isDynamic()) { - return new Updater(consumer, validator); + return new Updater(consumer, logger, validator); } else { throw new IllegalStateException("setting [" + getKey() + "] is not dynamic"); } @@ -596,9 +596,9 @@ AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Consum * See {@link AbstractScopedSettings#addSettingsUpdateConsumer(Setting, Setting, BiConsumer)} and its usage for details. */ static AbstractScopedSettings.SettingUpdater> compoundUpdater(final BiConsumer consumer, - final BiConsumer validator, final Setting aSetting, final Setting bSetting) { - final AbstractScopedSettings.SettingUpdater aSettingUpdater = aSetting.newUpdater(null); - final AbstractScopedSettings.SettingUpdater bSettingUpdater = bSetting.newUpdater(null); + final BiConsumer validator, final Setting aSetting, final Setting bSetting, Logger logger) { + final AbstractScopedSettings.SettingUpdater aSettingUpdater = aSetting.newUpdater(null, logger); + final AbstractScopedSettings.SettingUpdater bSettingUpdater = bSetting.newUpdater(null, logger); return new AbstractScopedSettings.SettingUpdater>() { @Override public boolean hasChanged(Settings current, Settings previous) { @@ -614,7 +614,7 @@ public Tuple getValue(Settings current, Settings previous) { } @Override - public void apply(Tuple value, Settings current, Settings previous, Logger logger) { + public void apply(Tuple value, Settings current, Settings previous) { if (aSettingUpdater.hasChanged(current, previous)) { logSettingUpdate(aSetting, current, previous, logger); } @@ -660,7 +660,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous, Logger logger) { + public void apply(Settings value, Settings current, Settings previous) { consumer.accept(value); } @@ -703,7 +703,7 @@ public Set> getSettingsDependencies(String settingsKey) { } AbstractScopedSettings.SettingUpdater, T>> newAffixUpdater( - BiConsumer consumer, BiConsumer validator) { + BiConsumer consumer, Logger logger, BiConsumer validator) { return new AbstractScopedSettings.SettingUpdater, T>>() { @Override @@ -719,7 +719,7 @@ public Map, T> getValue(Settings curren String namespace = key.getNamespace(aKey); Setting concreteSetting = getConcreteSetting(namespace, aKey); AbstractScopedSettings.SettingUpdater updater = - concreteSetting.newUpdater((v) -> consumer.accept(namespace, v), + concreteSetting.newUpdater((v) -> consumer.accept(namespace, v), logger, (v) -> validator.accept(namespace, v)); if (updater.hasChanged(current, previous)) { // only the ones that have changed otherwise we might get too many updates @@ -732,16 +732,15 @@ public Map, T> getValue(Settings curren } @Override - public void apply(Map, T> value, Settings current, - Settings previous, Logger logger) { + public void apply(Map, T> value, Settings current, Settings previous) { for (Map.Entry, T> entry : value.entrySet()) { - entry.getKey().apply(entry.getValue(), current, previous, logger); + entry.getKey().apply(entry.getValue(), current, previous); } } }; } - AbstractScopedSettings.SettingUpdater> newAffixMapUpdater(Consumer> consumer, + AbstractScopedSettings.SettingUpdater> newAffixMapUpdater(Consumer> consumer, Logger logger, BiConsumer validator) { return new AbstractScopedSettings.SettingUpdater>() { @@ -758,7 +757,7 @@ public Map getValue(Settings current, Settings previous) { String namespace = key.getNamespace(aKey); Setting concreteSetting = getConcreteSetting(namespace, aKey); AbstractScopedSettings.SettingUpdater updater = - concreteSetting.newUpdater((v) -> {}, (v) -> validator.accept(namespace, v)); + concreteSetting.newUpdater((v) -> {}, logger, (v) -> validator.accept(namespace, v)); if (updater.hasChanged(current, previous)) { // only the ones that have changed otherwise we might get too many updates // the hasChanged above checks only if there are any changes @@ -770,7 +769,7 @@ public Map getValue(Settings current, Settings previous) { } @Override - public void apply(Map value, Settings current, Settings previous, Logger logger) { + public void apply(Map value, Settings current, Settings previous) { consumer.accept(value); } }; @@ -965,7 +964,8 @@ public void diff(Settings.Builder builder, Settings source, Settings defaultSett } @Override - public AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Consumer validator) { + public AbstractScopedSettings.SettingUpdater newUpdater(Consumer consumer, Logger logger, + Consumer validator) { if (isDynamic() == false) { throw new IllegalStateException("setting [" + getKey() + "] is not dynamic"); } @@ -994,7 +994,7 @@ public Settings getValue(Settings current, Settings previous) { } @Override - public void apply(Settings value, Settings current, Settings previous, Logger logger) { + public void apply(Settings value, Settings current, Settings previous) { Setting.logSettingUpdate(GroupSetting.this, current, previous, logger); consumer.accept(value); } @@ -1009,10 +1009,12 @@ public String toString() { private final class Updater implements AbstractScopedSettings.SettingUpdater { private final Consumer consumer; + private final Logger logger; private final Consumer accept; - Updater(Consumer consumer, Consumer accept) { + Updater(Consumer consumer, Logger logger, Consumer accept) { this.consumer = consumer; + this.logger = logger; this.accept = accept; } @@ -1050,7 +1052,7 @@ public T getValue(Settings current, Settings previous) { } @Override - public void apply(T value, Settings current, Settings previous, Logger logger) { + public void apply(T value, Settings current, Settings previous) { logSettingUpdate(Setting.this, current, previous, logger); consumer.accept(value); } diff --git a/server/src/main/java/org/elasticsearch/index/IndexSettings.java b/server/src/main/java/org/elasticsearch/index/IndexSettings.java index 2cbd7f6b4e4a5..a1994d65c8d73 100644 --- a/server/src/main/java/org/elasticsearch/index/IndexSettings.java +++ b/server/src/main/java/org/elasticsearch/index/IndexSettings.java @@ -612,13 +612,6 @@ private void setRefreshInterval(TimeValue timeValue) { */ public Settings getSettings() { return settings; } - /** - * Returns the logger - */ - public Logger getLogger() { - return logger; - } - /** * Returns the index this settings object belongs to */ @@ -709,7 +702,7 @@ public synchronized boolean updateIndexMetaData(IndexMetaData indexMetaData) { // nothing to update, same settings return false; } - scopedSettings.applySettings(newSettings, logger); + scopedSettings.applySettings(newSettings); this.settings = newIndexSettings; return true; } diff --git a/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java b/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java index e2332e7bfd09f..39c5920f7d9d6 100644 --- a/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java +++ b/server/src/test/java/org/elasticsearch/action/support/AutoCreateIndexTests.java @@ -181,11 +181,11 @@ public void testUpdate() { assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(value)); Settings newSettings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), !value).build(); - clusterSettings.applySettings(newSettings, logger); + clusterSettings.applySettings(newSettings); assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(!value)); newSettings = Settings.builder().put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), "logs-*").build(); - clusterSettings.applySettings(newSettings, logger); + clusterSettings.applySettings(newSettings); assertThat(autoCreateIndex.getAutoCreate().isAutoCreateIndex(), equalTo(true)); assertThat(autoCreateIndex.getAutoCreate().getExpressions().size(), equalTo(1)); assertThat(autoCreateIndex.getAutoCreate().getExpressions().get(0).v1(), equalTo("logs-*")); diff --git a/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java b/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java index ff322feb1cf51..df73a2542e6c2 100644 --- a/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/coordination/NoMasterBlockServiceTests.java @@ -62,7 +62,7 @@ public void testSettingCanBeUpdated() { createService(Settings.builder().put(NO_MASTER_BLOCK_SETTING.getKey(), "all").build()); assertThat(noMasterBlockService.getNoMasterBlock(), sameInstance(NO_MASTER_BLOCK_ALL)); - clusterSettings.applySettings(Settings.builder().put(NO_MASTER_BLOCK_SETTING.getKey(), "write").build(), logger); + clusterSettings.applySettings(Settings.builder().put(NO_MASTER_BLOCK_SETTING.getKey(), "write").build()); assertThat(noMasterBlockService.getNoMasterBlock(), sameInstance(NO_MASTER_BLOCK_WRITES)); } } diff --git a/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java b/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java index 562141c3c4ca3..a1d12d98398ca 100644 --- a/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/coordination/ReconfiguratorTests.java @@ -225,7 +225,7 @@ public void testDynamicSetting() { assertThat(reconfigurator.reconfigure(twoNodes, retired(), randomFrom(twoNodes), initialConfig), equalTo(conf("a", "b", "c"))); // update to "false" - clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "false").build(), logger); + clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "false").build()); assertThat(reconfigurator.reconfigure(twoNodes, retired(), randomFrom(twoNodes), initialConfig), sameInstance(initialConfig)); // no quorum assertThat(reconfigurator.reconfigure(threeNodes, retired(), randomFrom(threeNodes), initialConfig), @@ -234,10 +234,10 @@ public void testDynamicSetting() { equalTo(conf("a", "b", "c", "e"))); // explicitly set to "true" - clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "true").build(), logger); + clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "true").build()); assertThat(reconfigurator.reconfigure(twoNodes, retired(), randomFrom(twoNodes), initialConfig), equalTo(conf("a", "b", "c"))); - expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings( - Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "blah").build(), logger)); + expectThrows(IllegalArgumentException.class, () -> + clusterSettings.applySettings(Settings.builder().put(CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION.getKey(), "blah").build())); } } diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java index 54fd011823157..81ccdc35b248e 100644 --- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/BalanceConfigurationTests.java @@ -256,7 +256,7 @@ public void testPersistedSettings() { settings.put(BalancedShardsAllocator.THRESHOLD_SETTING.getKey(), 2.0); settings.put(ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(), ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString()); - service.applySettings(settings.build(), logger); + service.applySettings(settings.build()); assertThat(allocator.getIndexBalance(), Matchers.equalTo(0.2f)); assertThat(allocator.getShardBalance(), Matchers.equalTo(0.3f)); assertThat(allocator.getThreshold(), Matchers.equalTo(2.0f)); @@ -265,7 +265,7 @@ public void testPersistedSettings() { settings.put(BalancedShardsAllocator.INDEX_BALANCE_FACTOR_SETTING.getKey(), 0.5); settings.put(BalancedShardsAllocator.SHARD_BALANCE_FACTOR_SETTING.getKey(), 0.1); settings.put(BalancedShardsAllocator.THRESHOLD_SETTING.getKey(), 3.0); - service.applySettings(settings.build(), logger); + service.applySettings(settings.build()); assertThat(allocator.getIndexBalance(), Matchers.equalTo(0.5f)); assertThat(allocator.getShardBalance(), Matchers.equalTo(0.1f)); assertThat(allocator.getThreshold(), Matchers.equalTo(3.0f)); diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java index 99d76ec84345a..5bbd3ab33ce74 100644 --- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/DiskThresholdSettingsTests.java @@ -59,7 +59,7 @@ public void testUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "250mb") .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_REROUTE_INTERVAL_SETTING.getKey(), "30s") .build(); - nss.applySettings(newSettings, logger); + nss.applySettings(newSettings); assertEquals(ByteSizeValue.parseBytesSizeValue("500mb", "test"), diskThresholdSettings.getFreeBytesThresholdHigh()); assertEquals(0.0D, diskThresholdSettings.getFreeDiskThresholdHigh(), 0.0D); @@ -91,8 +91,7 @@ public void testInvalidLowHighPercentageUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), "80%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> clusterSettings.applySettings(newSettings, logger)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [90%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -111,8 +110,7 @@ public void testInvalidHighFloodPercentageUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "55%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> clusterSettings.applySettings(newSettings, logger)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [50%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -131,8 +129,7 @@ public void testInvalidLowHighBytesUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "250m") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> clusterSettings.applySettings(newSettings, logger)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [500m]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -151,8 +148,7 @@ public void testInvalidHighFloodBytesUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "750m") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> clusterSettings.applySettings(newSettings, logger)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [500m]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -171,8 +167,7 @@ public void testIncompatibleThresholdUpdate() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), "95%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> clusterSettings.applySettings(newSettings, logger)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.low] from [85%] to [90%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); @@ -198,8 +193,7 @@ public void testInvalidHighDiskThreshold() { .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), "75%") .build(); - final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> clusterSettings.applySettings(newSettings, logger)); + final IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> clusterSettings.applySettings(newSettings)); final String expected = "illegal value can't update [cluster.routing.allocation.disk.watermark.high] from [90%] to [75%]"; assertThat(e, hasToString(containsString(expected))); assertNotNull(e.getCause()); diff --git a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java index 75eea9519f7ce..c342443ad707b 100644 --- a/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java +++ b/server/src/test/java/org/elasticsearch/cluster/routing/allocation/decider/EnableAllocationTests.java @@ -221,7 +221,7 @@ public void testEnableClusterBalance() { .put(EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), allowedOnes).build()))).build(); } - clusterSettings.applySettings(clusterState.metaData().settings(), logger); + clusterSettings.applySettings(clusterState.metaData().settings()); clusterState = strategy.reroute(clusterState, "reroute"); assertThat("expected 6 shards to be started 2 to relocate useClusterSettings: " + useClusterSetting, clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(6)); @@ -312,7 +312,7 @@ public void testEnableClusterBalanceNoReplicas() { .put(EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), randomBoolean() ? Rebalance.PRIMARIES : Rebalance.ALL).build()))).build(); } - clusterSettings.applySettings(clusterState.metaData().settings(), logger); + clusterSettings.applySettings(clusterState.metaData().settings()); clusterState = strategy.reroute(clusterState, "reroute"); assertThat("expected 4 primaries to be started and 2 to relocate useClusterSettings: " + useClusterSetting, clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(4)); diff --git a/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java b/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java index 238ca666758ea..6c0f6b0751a65 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/ScopedSettingsTests.java @@ -170,7 +170,7 @@ public void testAddConsumer() { } assertEquals(0, consumer.get()); assertEquals(0, consumer2.get()); - service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build(), logger); + service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build()); assertEquals(2, consumer.get()); assertEquals(0, consumer2.get()); } @@ -251,7 +251,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group2), "18", "19", "20") - .build(), logger); + .build()); assertEquals(2, results.get(group1).v2().intValue()); assertEquals(7, results.get(group2).v2().intValue()); assertEquals(Arrays.asList(16, 17), results.get(group1).v1()); @@ -265,7 +265,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putNull(listBuilder.apply(group2)) // removed - .build(), logger); + .build()); assertNull(group1 + " wasn't changed", results.get(group1)); assertEquals(1, results.get(group2).v1().size()); @@ -279,7 +279,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") // added - .build(), logger); + .build()); assertNull(group1 + " wasn't changed", results.get(group1)); assertNull(group2 + " wasn't changed", results.get(group2)); @@ -294,7 +294,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") - .build(), logger); + .build()); assertNull(group2 + " wasn't changed", results.get(group2)); assertNull(group3 + " wasn't changed", results.get(group3)); @@ -310,7 +310,7 @@ public void testTupleAffixUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1)) // modified to trip validator .putList(listBuilder.apply(group3), "5", "6") - .build(), logger) + .build()) ); assertEquals("boom", iae.getMessage()); assertEquals(0, results.size()); @@ -340,7 +340,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group2), "18", "19", "20") - .build(), logger); + .build()); Settings groupOneSettings = results.get(group1); Settings groupTwoSettings = results.get(group2); assertEquals(2, intSetting.getConcreteSettingForNamespace(group1).get(groupOneSettings).intValue()); @@ -358,7 +358,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putNull(listBuilder.apply(group2)) // removed - .build(), logger); + .build()); assertNull(group1 + " wasn't changed", results.get(group1)); groupTwoSettings = results.get(group2); @@ -373,7 +373,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") // added - .build(), logger); + .build()); assertNull(group1 + " wasn't changed", results.get(group1)); assertNull(group2 + " wasn't changed", results.get(group2)); @@ -389,7 +389,7 @@ public void testAffixGroupUpdateConsumer() { .put(intBuilder.apply(group2), 7) .putList(listBuilder.apply(group1), "16", "17") .putList(listBuilder.apply(group3), "5", "6") - .build(), logger); + .build()); assertNull(group2 + " wasn't changed", results.get(group2)); assertNull(group3 + " wasn't changed", results.get(group3)); @@ -422,7 +422,7 @@ public void testAddConsumerAffix() { .put("foo.test_1.bar", 7) .putList("foo.test_list.list", "16", "17") .putList("foo.test_list_1.list", "18", "19", "20") - .build(), logger); + .build()); assertEquals(2, intResults.get("test").intValue()); assertEquals(7, intResults.get("test_1").intValue()); assertEquals(Arrays.asList(16, 17), listResults.get("test_list")); @@ -438,7 +438,7 @@ public void testAddConsumerAffix() { .put("foo.test_1.bar", 8) .putList("foo.test_list.list", "16", "17") .putNull("foo.test_list_1.list") - .build(), logger); + .build()); assertNull("test wasn't changed", intResults.get("test")); assertEquals(8, intResults.get("test_1").intValue()); assertNull("test_list wasn't changed", listResults.get("test_list")); @@ -473,7 +473,7 @@ public void testAddConsumerAffixMap() { .put("foo.test_1.bar", 7) .putList("foo.test_list.list", "16", "17") .putList("foo.test_list_1.list", "18", "19", "20") - .build(), logger); + .build()); assertEquals(2, intResults.get("test").intValue()); assertEquals(7, intResults.get("test_1").intValue()); assertEquals(Arrays.asList(16, 17), listResults.get("test_list")); @@ -486,7 +486,7 @@ public void testAddConsumerAffixMap() { .put("foo.test_1.bar", 7) .putList("foo.test_list.list", "16", "17") .putList("foo.test_list_1.list", "18", "19", "20") - .build(), logger); + .build()); assertEquals(2, intResults.get("test").intValue()); assertEquals(7, intResults.get("test_1").intValue()); @@ -503,7 +503,7 @@ public void testAddConsumerAffixMap() { .put("foo.test_1.bar", 8) .putList("foo.test_list.list", "16", "17") .putNull("foo.test_list_1.list") - .build(), logger); + .build()); assertNull("test wasn't changed", intResults.get("test")); assertEquals(8, intResults.get("test_1").intValue()); assertNull("test_list wasn't changed", listResults.get("test_list")); @@ -529,14 +529,14 @@ public void testAffixMapConsumerNotCalledWithNull() { assertEquals(0, affixResults.size()); service.applySettings(Settings.builder() .put("eggplant._name", 2) - .build(), logger); + .build()); assertThat(affixResults.size(), equalTo(1)); assertThat(affixResults.get("_name"), equalTo(2)); service.applySettings(Settings.builder() .put("eggplant._name", 2) .put("other.thing", 3) - .build(), logger); + .build()); assertThat(affixResults.get("_name"), equalTo(2)); } @@ -563,7 +563,7 @@ public void testApply() { assertEquals(0, aC.get()); assertEquals(0, bC.get()); try { - service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", -15).build(), logger); + service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", -15).build()); fail("invalid value"); } catch (IllegalArgumentException ex) { assertEquals("illegal value can't update [foo.bar.baz] from [1] to [-15]", ex.getMessage()); @@ -589,7 +589,7 @@ public void testApply() { assertEquals(0, aC.get()); assertEquals(0, bC.get()); - service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build(), logger); + service.applySettings(Settings.builder().put("foo.bar", 2).put("foo.bar.baz", 15).build()); assertEquals(2, consumer.get()); assertEquals(15, consumer2.get()); assertEquals(2, aC.get()); @@ -752,7 +752,7 @@ public void testUpdateTracer() { AtomicReference> ref = new AtomicReference<>(); settings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, ref::set); settings.applySettings(Settings.builder() - .putList("transport.tracer.include", "internal:index/shard/recovery/*", "internal:gateway/local*").build(), logger); + .putList("transport.tracer.include", "internal:index/shard/recovery/*", "internal:gateway/local*").build()); assertNotNull(ref.get().size()); assertEquals(ref.get().size(), 2); assertTrue(ref.get().contains("internal:index/shard/recovery/*")); @@ -912,13 +912,13 @@ public void testLoggingUpdates() { () -> settings.validate(Settings.builder().put("logger._root", "boom").build(), false)); assertEquals("Unknown level constant [BOOM].", ex.getMessage()); assertEquals(level, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().put("logger._root", "TRACE").build(), logger); + settings.applySettings(Settings.builder().put("logger._root", "TRACE").build()); assertEquals(Level.TRACE, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().build(), logger); + settings.applySettings(Settings.builder().build()); assertEquals(property, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().put("logger.test", "TRACE").build(), logger); + settings.applySettings(Settings.builder().put("logger.test", "TRACE").build()); assertEquals(Level.TRACE, LogManager.getLogger("test").getLevel()); - settings.applySettings(Settings.builder().build(), logger); + settings.applySettings(Settings.builder().build()); assertEquals(property, LogManager.getLogger("test").getLevel()); } finally { Loggers.setLevel(LogManager.getRootLogger(), level); @@ -932,9 +932,9 @@ public void testFallbackToLoggerLevel() { ClusterSettings settings = new ClusterSettings(Settings.builder().put("logger.level", "ERROR").build(), ClusterSettings.BUILT_IN_CLUSTER_SETTINGS); assertEquals(level, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().put("logger._root", "TRACE").build(), logger); + settings.applySettings(Settings.builder().put("logger._root", "TRACE").build()); assertEquals(Level.TRACE, LogManager.getRootLogger().getLevel()); - settings.applySettings(Settings.builder().build(), logger); // here we fall back to 'logger.level' which is our default. + settings.applySettings(Settings.builder().build()); // here we fall back to 'logger.level' which is our default. assertEquals(Level.ERROR, LogManager.getRootLogger().getLevel()); } finally { Loggers.setLevel(LogManager.getRootLogger(), level); diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java index dc967400fb694..6df1eab6fb2a7 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java @@ -18,11 +18,11 @@ */ package org.elasticsearch.common.settings; +import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.core.LogEvent; import org.apache.logging.log4j.core.appender.AbstractAppender; import org.apache.logging.log4j.core.filter.RegexFilter; import org.apache.logging.log4j.core.impl.MementoMessage; -import org.elasticsearch.Version; import org.elasticsearch.cluster.metadata.IndexMetaData; import org.elasticsearch.common.collect.Tuple; import org.elasticsearch.common.logging.Loggers; @@ -128,18 +128,18 @@ public void testByteSizeSettingValidation() { final ByteSizeValue byteSizeValue = byteSizeValueSetting.get(Settings.EMPTY); assertThat(byteSizeValue.getBytes(), equalTo(2048L)); AtomicReference value = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = byteSizeValueSetting.newUpdater(value::set); + ClusterSettings.SettingUpdater settingUpdater = byteSizeValueSetting.newUpdater(value::set, logger); final IllegalArgumentException e = expectThrows( IllegalArgumentException.class, - () -> settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY, logger)); + () -> settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY)); assertThat(e, hasToString(containsString("illegal value can't update [a.byte.size] from [2048b] to [12]"))); assertNotNull(e.getCause()); assertThat(e.getCause(), instanceOf(IllegalArgumentException.class)); final IllegalArgumentException cause = (IllegalArgumentException) e.getCause(); final String expected = "failed to parse setting [a.byte.size] with value [12] as a size in bytes: unit is missing or unrecognized"; assertThat(cause, hasToString(containsString(expected))); - assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY, logger)); + assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY)); assertThat(value.get(), equalTo(new ByteSizeValue(12))); } @@ -165,9 +165,9 @@ public void testMemorySize() { assertEquals(memorySizeValue.getBytes(), JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.25, 1.0); AtomicReference value = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = memorySizeValueSetting.newUpdater(value::set); + ClusterSettings.SettingUpdater settingUpdater = memorySizeValueSetting.newUpdater(value::set, logger); try { - settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY, logger); + settingUpdater.apply(Settings.builder().put("a.byte.size", 12).build(), Settings.EMPTY); fail("no unit"); } catch (IllegalArgumentException ex) { assertThat(ex, hasToString(containsString("illegal value can't update [a.byte.size] from [25%] to [12]"))); @@ -179,28 +179,28 @@ public void testMemorySize() { assertThat(cause, hasToString(containsString(expected))); } - assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY, logger)); + assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "12b").build(), Settings.EMPTY)); assertEquals(new ByteSizeValue(12), value.get()); - assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "20%").build(), Settings.EMPTY, logger)); + assertTrue(settingUpdater.apply(Settings.builder().put("a.byte.size", "20%").build(), Settings.EMPTY)); assertEquals(new ByteSizeValue((int) (JvmInfo.jvmInfo().getMem().getHeapMax().getBytes() * 0.2)), value.get()); } public void testSimpleUpdate() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope); AtomicReference atomicBoolean = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set); + ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set, logger); Settings build = Settings.builder().put("foo.bar", false).build(); - settingUpdater.apply(build, Settings.EMPTY, logger); + settingUpdater.apply(build, Settings.EMPTY); assertNull(atomicBoolean.get()); build = Settings.builder().put("foo.bar", true).build(); - settingUpdater.apply(build, Settings.EMPTY, logger); + settingUpdater.apply(build, Settings.EMPTY); assertTrue(atomicBoolean.get()); // try update bogus value build = Settings.builder().put("foo.bar", "I am not a boolean").build(); try { - settingUpdater.apply(build, Settings.EMPTY, logger); + settingUpdater.apply(build, Settings.EMPTY); fail("not a boolean"); } catch (IllegalArgumentException ex) { assertThat(ex, hasToString(containsString("illegal value can't update [foo.bar] from [false] to [I am not a boolean]"))); @@ -215,12 +215,11 @@ public void testSimpleUpdate() { public void testSimpleUpdateOfFilteredSetting() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.Filtered); AtomicReference atomicBoolean = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set); + ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(atomicBoolean::set, logger); // try update bogus value Settings build = Settings.builder().put("foo.bar", "I am not a boolean").build(); - IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, - () -> settingUpdater.apply(build, Settings.EMPTY, logger)); + IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(build, Settings.EMPTY)); assertThat(ex, hasToString(equalTo("java.lang.IllegalArgumentException: illegal value can't update [foo.bar]"))); assertNull(ex.getCause()); } @@ -378,7 +377,7 @@ public void testUpdateNotDynamic() { assertFalse(booleanSetting.isGroupSetting()); AtomicReference atomicBoolean = new AtomicReference<>(null); try { - booleanSetting.newUpdater(atomicBoolean::set); + booleanSetting.newUpdater(atomicBoolean::set, logger); fail("not dynamic"); } catch (IllegalStateException ex) { assertEquals("setting [foo.bar] is not dynamic", ex.getMessage()); @@ -389,8 +388,8 @@ public void testUpdaterIsIsolated() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope); AtomicReference ab1 = new AtomicReference<>(null); AtomicReference ab2 = new AtomicReference<>(null); - ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(ab1::set); - settingUpdater.apply(Settings.builder().put("foo.bar", true).build(), Settings.EMPTY, logger); + ClusterSettings.SettingUpdater settingUpdater = booleanSetting.newUpdater(ab1::set, logger); + settingUpdater.apply(Settings.builder().put("foo.bar", true).build(), Settings.EMPTY); assertTrue(ab1.get()); assertNull(ab2.get()); } @@ -436,18 +435,18 @@ public void testComplexType() { assertFalse(setting.isGroupSetting()); ref.set(setting.get(Settings.EMPTY)); ComplexType type = ref.get(); - ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set); - assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY, logger)); + ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set, logger); + assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY)); assertSame("no update - type has not changed", type, ref.get()); // change from default - assertTrue(settingUpdater.apply(Settings.builder().put("foo.bar", "2").build(), Settings.EMPTY, logger)); + assertTrue(settingUpdater.apply(Settings.builder().put("foo.bar", "2").build(), Settings.EMPTY)); assertNotSame("update - type has changed", type, ref.get()); assertEquals("2", ref.get().foo); // change back to default... - assertTrue(settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "2").build(), logger)); + assertTrue(settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "2").build())); assertNotSame("update - type has changed", type, ref.get()); assertEquals("", ref.get().foo); } @@ -465,14 +464,14 @@ public void testGroups() { AtomicReference ref = new AtomicReference<>(null); Setting setting = Setting.groupSetting("foo.bar.", Property.Dynamic, Property.NodeScope); assertTrue(setting.isGroupSetting()); - ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set); + ClusterSettings.SettingUpdater settingUpdater = setting.newUpdater(ref::set, logger); Settings currentInput = Settings.builder() .put("foo.bar.1.value", "1") .put("foo.bar.2.value", "2") .put("foo.bar.3.value", "3").build(); Settings previousInput = Settings.EMPTY; - assertTrue(settingUpdater.apply(currentInput, previousInput, logger)); + assertTrue(settingUpdater.apply(currentInput, previousInput)); assertNotNull(ref.get()); Settings settings = ref.get(); Map asMap = settings.getAsGroups(); @@ -484,13 +483,13 @@ public void testGroups() { previousInput = currentInput; currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").put("foo.bar.3.value", "3").build(); Settings current = ref.get(); - assertFalse(settingUpdater.apply(currentInput, previousInput, logger)); + assertFalse(settingUpdater.apply(currentInput, previousInput)); assertSame(current, ref.get()); previousInput = currentInput; currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(); // now update and check that we got it - assertTrue(settingUpdater.apply(currentInput, previousInput, logger)); + assertTrue(settingUpdater.apply(currentInput, previousInput)); assertNotSame(current, ref.get()); asMap = ref.get().getAsGroups(); @@ -501,7 +500,7 @@ public void testGroups() { previousInput = currentInput; currentInput = Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "4").build(); // now update and check that we got it - assertTrue(settingUpdater.apply(currentInput, previousInput, logger)); + assertTrue(settingUpdater.apply(currentInput, previousInput)); assertNotSame(current, ref.get()); asMap = ref.get().getAsGroups(); @@ -512,10 +511,10 @@ public void testGroups() { assertTrue(setting.match("foo.bar.baz")); assertFalse(setting.match("foo.baz.bar")); - ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set,(s) -> assertFalse(true)); + ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set, logger,(s) -> assertFalse(true)); try { predicateSettingUpdater.apply(Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(), - Settings.EMPTY, logger); + Settings.EMPTY); fail("not accepted"); } catch (IllegalArgumentException ex) { assertEquals(ex.getMessage(), "illegal value can't update [foo.bar.] from [{}] to [{\"1.value\":\"1\",\"2.value\":\"2\"}]"); @@ -526,10 +525,10 @@ public void testFilteredGroups() { AtomicReference ref = new AtomicReference<>(null); Setting setting = Setting.groupSetting("foo.bar.", Property.Filtered, Property.Dynamic); - ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set, (s) -> assertFalse(true)); + ClusterSettings.SettingUpdater predicateSettingUpdater = setting.newUpdater(ref::set, logger, (s) -> assertFalse(true)); IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> predicateSettingUpdater.apply(Settings.builder().put("foo.bar.1.value", "1").put("foo.bar.2.value", "2").build(), - Settings.EMPTY, logger)); + Settings.EMPTY)); assertEquals("illegal value can't update [foo.bar.]", ex.getMessage()); } @@ -564,27 +563,27 @@ public void testComposite() { Composite c = new Composite(); Setting a = Setting.intSetting("foo.int.bar.a", 1, Property.Dynamic, Property.NodeScope); Setting b = Setting.intSetting("foo.int.bar.b", 1, Property.Dynamic, Property.NodeScope); - ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b); - assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY, logger)); + ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b, logger); + assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY)); assertNull(c.a); assertNull(c.b); Settings build = Settings.builder().put("foo.int.bar.a", 2).build(); - assertTrue(settingUpdater.apply(build, Settings.EMPTY, logger)); + assertTrue(settingUpdater.apply(build, Settings.EMPTY)); assertEquals(2, c.a.intValue()); assertEquals(1, c.b.intValue()); Integer aValue = c.a; - assertFalse(settingUpdater.apply(build, build, logger)); + assertFalse(settingUpdater.apply(build, build)); assertSame(aValue, c.a); Settings previous = build; build = Settings.builder().put("foo.int.bar.a", 2).put("foo.int.bar.b", 5).build(); - assertTrue(settingUpdater.apply(build, previous, logger)); + assertTrue(settingUpdater.apply(build, previous)); assertEquals(2, c.a.intValue()); assertEquals(5, c.b.intValue()); // reset to default - assertTrue(settingUpdater.apply(Settings.EMPTY, build, logger)); + assertTrue(settingUpdater.apply(Settings.EMPTY, build)); assertEquals(1, c.a.intValue()); assertEquals(1, c.b.intValue()); @@ -594,31 +593,31 @@ public void testCompositeValidator() { Composite c = new Composite(); Setting a = Setting.intSetting("foo.int.bar.a", 1, Property.Dynamic, Property.NodeScope); Setting b = Setting.intSetting("foo.int.bar.b", 1, Property.Dynamic, Property.NodeScope); - ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b); - assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY, logger)); + ClusterSettings.SettingUpdater> settingUpdater = Setting.compoundUpdater(c::set, c::validate, a, b, logger); + assertFalse(settingUpdater.apply(Settings.EMPTY, Settings.EMPTY)); assertNull(c.a); assertNull(c.b); Settings build = Settings.builder().put("foo.int.bar.a", 2).build(); - assertTrue(settingUpdater.apply(build, Settings.EMPTY, logger)); + assertTrue(settingUpdater.apply(build, Settings.EMPTY)); assertEquals(2, c.a.intValue()); assertEquals(1, c.b.intValue()); Integer aValue = c.a; - assertFalse(settingUpdater.apply(build, build, logger)); + assertFalse(settingUpdater.apply(build, build)); assertSame(aValue, c.a); Settings previous = build; build = Settings.builder().put("foo.int.bar.a", 2).put("foo.int.bar.b", 5).build(); - assertTrue(settingUpdater.apply(build, previous, logger)); + assertTrue(settingUpdater.apply(build, previous)); assertEquals(2, c.a.intValue()); assertEquals(5, c.b.intValue()); Settings invalid = Settings.builder().put("foo.int.bar.a", -2).put("foo.int.bar.b", 5).build(); - IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(invalid, previous, logger)); + IllegalArgumentException exc = expectThrows(IllegalArgumentException.class, () -> settingUpdater.apply(invalid, previous)); assertThat(exc.getMessage(), equalTo("boom")); // reset to default - assertTrue(settingUpdater.apply(Settings.EMPTY, build, logger)); + assertTrue(settingUpdater.apply(Settings.EMPTY, build)); assertEquals(1, c.a.intValue()); assertEquals(1, c.b.intValue()); @@ -670,22 +669,21 @@ public void testListSettings() { assertTrue(listSetting.exists(builder.build())); AtomicReference> ref = new AtomicReference<>(); - AbstractScopedSettings.SettingUpdater> settingUpdater = listSetting.newUpdater(ref::set); + AbstractScopedSettings.SettingUpdater> settingUpdater = listSetting.newUpdater(ref::set, logger); assertTrue(settingUpdater.hasChanged(builder.build(), Settings.EMPTY)); - settingUpdater.apply(builder.build(), Settings.EMPTY, logger); + settingUpdater.apply(builder.build(), Settings.EMPTY); assertEquals(input.size(), ref.get().size()); assertArrayEquals(ref.get().toArray(new String[0]), input.toArray(new String[0])); - settingUpdater.apply(Settings.builder().putList("foo.bar", "123").build(), builder.build(), logger); + settingUpdater.apply(Settings.builder().putList("foo.bar", "123").build(), builder.build()); assertEquals(1, ref.get().size()); assertArrayEquals(ref.get().toArray(new String[0]), new String[] {"123"}); - settingUpdater.apply(Settings.builder().put("foo.bar", "1,2,3").build(), - Settings.builder().putList("foo.bar", "123").build(), logger); + settingUpdater.apply(Settings.builder().put("foo.bar", "1,2,3").build(), Settings.builder().putList("foo.bar", "123").build()); assertEquals(3, ref.get().size()); assertArrayEquals(ref.get().toArray(new String[0]), new String[] {"1", "2", "3"}); - settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "1,2,3").build(), logger); + settingUpdater.apply(Settings.EMPTY, Settings.builder().put("foo.bar", "1,2,3").build()); assertEquals(1, ref.get().size()); assertEquals("foo,bar", ref.get().get(0)); @@ -980,7 +978,7 @@ public void testSettingsGroupUpdater() { Settings current = Settings.builder().put("prefix.foo", 123).put("prefix.same", 5555).build(); Settings previous = Settings.builder().put("prefix.foo", 321).put("prefix.same", 5555).build(); - assertTrue(updater.apply(current, previous, logger)); + assertTrue(updater.apply(current, previous)); } public void testSettingsGroupUpdaterRemoval() { @@ -991,7 +989,7 @@ public void testSettingsGroupUpdaterRemoval() { Settings current = Settings.builder().put("prefix.same", 5555).build(); Settings previous = Settings.builder().put("prefix.foo", 321).put("prefix.same", 5555).build(); - assertTrue(updater.apply(current, previous, logger)); + assertTrue(updater.apply(current, previous)); } public void testSettingsGroupUpdaterWithAffixSetting() { @@ -1036,7 +1034,7 @@ public void testSettingsGroupUpdaterWithAffixSetting() { boolean expectedChange = removeAffixKeySetting || removePrefixKeySetting || changeAffixKeySetting || changePrefixKeySetting || removeAffixNamespace; - assertThat(updater.apply(currentSettingsBuilder.build(), previousSettingsBuilder.build(), logger), is(expectedChange)); + assertThat(updater.apply(currentSettingsBuilder.build(), previousSettingsBuilder.build()), is(expectedChange)); } public void testAffixNamespacesWithGroupSetting() { @@ -1098,7 +1096,7 @@ public void testAffixMapUpdateWithNullSettingValue() { final BiConsumer validator = (s1, s2) -> {}; // WHEN creating an affix updater - final SettingUpdater> updater = affixSetting.newAffixMapUpdater(consumer, validator); + final SettingUpdater> updater = affixSetting.newAffixMapUpdater(consumer, logger, validator); // THEN affix updater is always expected to have changed (even when defaults are omitted) assertTrue(updater.hasChanged(current, previous)); @@ -1125,20 +1123,19 @@ public void testNonSecureSettingInKeystore() { } public void testLogSettingUpdate() throws Exception { - IndexMetaData metaData = newIndexMeta("index1", Settings.builder() - .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT) - .put(IndexSettings.INDEX_WARMER_ENABLED_SETTING.getKey(), false) - .build()); + IndexMetaData metaData = newIndexMeta("index1", + Settings.builder().put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "20s").build()); IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY); + Logger logger = settings.getScopedSettings().getLogger(); - MockAppender appender = new MockAppender("logSettingUpdate"); + MockAppender appender = new MockAppender("trace_appender"); appender.start(); - Loggers.addAppender(settings.getLogger(), appender); + Loggers.addAppender(logger, appender); - settings.updateIndexMetaData(newIndexMeta("index1", Settings.builder().put(IndexSettings.INDEX_WARMER_ENABLED_SETTING.getKey(), - "true").build())); + settings.updateIndexMetaData(newIndexMeta("index1", + Settings.builder().put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "10s").build())); - assertThat(appender.lastMementoMessage().getFormattedMessage(), equalTo("updating [index.warmer.enabled] from [false] to [true]")); + assertThat(appender.lastMementoMessage().getFormattedMessage(), equalTo("updating [index.refresh_interval] from [20s] to [10s]")); assertThat(appender.getLoggerMaker(), equalTo(" [index1]")); appender.stop(); } diff --git a/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java b/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java index a03a6412be6e1..65432466c61a1 100644 --- a/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java +++ b/server/src/test/java/org/elasticsearch/gateway/IncrementalClusterStateWriterTests.java @@ -490,7 +490,7 @@ public void testSlowLogging() throws WriteStateException, IllegalAccessException clusterSettings.applySettings(Settings.builder() .put(IncrementalClusterStateWriter.SLOW_WRITE_LOGGING_THRESHOLD.getKey(), writeDurationMillis.get() + "ms") - .build(), logger); + .build()); assertExpectedLogs(clusterState, incrementalClusterStateWriter, new MockLogAppender.SeenEventExpectation( "should see warning at reduced threshold", IncrementalClusterStateWriter.class.getCanonicalName(), diff --git a/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java b/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java index 1bbd0c03bdf99..93867f4aa4c77 100644 --- a/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java +++ b/server/src/test/java/org/elasticsearch/index/shard/IndexShardTests.java @@ -3053,7 +3053,7 @@ public void testReadSnapshotConcurrently() throws IOException, InterruptedExcept expectThrows(AlreadyClosedException.class, () -> newShard.getEngine()); // no engine Thread thread = new Thread(() -> { latch.countDown(); - while(stop.get() == false) { + while(stop.get() == false){ try { Store.MetadataSnapshot readMeta = newShard.snapshotStoreMetadata(); assertEquals(0, storeFileMetaDatas.recoveryDiff(readMeta).different.size()); @@ -3332,17 +3332,17 @@ public void testIsSearchIdle() throws Exception { IndexScopedSettings scopedSettings = primary.indexSettings().getScopedSettings(); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.ZERO).build(); - scopedSettings.applySettings(settings, logger); + scopedSettings.applySettings(settings); assertTrue(primary.isSearchIdle()); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.timeValueMinutes(1)) .build(); - scopedSettings.applySettings(settings, logger); + scopedSettings.applySettings(settings); assertFalse(primary.isSearchIdle()); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.timeValueMillis(10)) .build(); - scopedSettings.applySettings(settings, logger); + scopedSettings.applySettings(settings); assertBusy(() -> assertTrue(primary.isSearchIdle())); do { @@ -3374,7 +3374,7 @@ public void testScheduledRefresh() throws Exception { assertTrue(primary.scheduledRefresh()); IndexScopedSettings scopedSettings = primary.indexSettings().getScopedSettings(); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.ZERO).build(); - scopedSettings.applySettings(settings, logger); + scopedSettings.applySettings(settings); assertFalse(primary.getEngine().refreshNeeded()); indexDoc(primary, "_doc", "1", "{\"foo\" : \"bar\"}"); @@ -3451,7 +3451,7 @@ public void testRefreshIsNeededWithRefreshListeners() throws IOException, Interr IndexScopedSettings scopedSettings = primary.indexSettings().getScopedSettings(); settings = Settings.builder().put(settings).put(IndexSettings.INDEX_SEARCH_IDLE_AFTER.getKey(), TimeValue.ZERO).build(); - scopedSettings.applySettings(settings, logger); + scopedSettings.applySettings(settings); doc = indexDoc(primary, "_doc", "2", "{\"foo\" : \"bar\"}"); CountDownLatch latch1 = new CountDownLatch(1); diff --git a/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java b/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java index d8081ef7fd50c..54e082098763e 100644 --- a/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java +++ b/server/src/test/java/org/elasticsearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java @@ -33,7 +33,7 @@ public class RecoverySettingsDynamicUpdateTests extends ESTestCase { public void testZeroBytesPerSecondIsNoRateLimit() { clusterSettings.applySettings(Settings.builder().put( - RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), 0).build(), logger); + RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), 0).build()); assertEquals(null, recoverySettings.rateLimiter()); } @@ -42,7 +42,7 @@ public void testRetryDelayStateSync() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_RETRY_DELAY_STATE_SYNC_SETTING.getKey(), duration, timeUnit - ).build(), logger); + ).build()); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.retryDelayStateSync()); } @@ -51,7 +51,7 @@ public void testRetryDelayNetwork() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_RETRY_DELAY_NETWORK_SETTING.getKey(), duration, timeUnit - ).build(), logger); + ).build()); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.retryDelayNetwork()); } @@ -60,7 +60,7 @@ public void testActivityTimeout() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_ACTIVITY_TIMEOUT_SETTING.getKey(), duration, timeUnit - ).build(), logger); + ).build()); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.activityTimeout()); } @@ -69,7 +69,7 @@ public void testInternalActionTimeout() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_INTERNAL_ACTION_TIMEOUT_SETTING.getKey(), duration, timeUnit - ).build(), logger); + ).build()); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.internalActionTimeout()); } @@ -78,7 +78,7 @@ public void testInternalLongActionTimeout() { TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS); clusterSettings.applySettings(Settings.builder().put( RecoverySettings.INDICES_RECOVERY_INTERNAL_LONG_ACTION_TIMEOUT_SETTING.getKey(), duration, timeUnit - ).build(), logger); + ).build()); assertEquals(new TimeValue(duration, timeUnit), recoverySettings.internalActionLongTimeout()); } } diff --git a/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java b/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java index f83a6de59d828..2007c350b555b 100644 --- a/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java +++ b/server/src/test/java/org/elasticsearch/persistent/PersistentTasksDecidersTestCase.java @@ -92,7 +92,7 @@ protected void updateSettings(final Settings settings) { ClusterSettings clusterSettings = clusterService.getClusterSettings(); Settings.Builder updated = Settings.builder(); clusterSettings.updateDynamicSettings(settings, updated, Settings.builder(), getTestClass().getName()); - clusterSettings.applySettings(updated.build(), logger); + clusterSettings.applySettings(updated.build()); } protected static ClusterState createClusterStateWithTasks(final int nbNodes, final int nbTasks) { diff --git a/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java b/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java index 5cbf00283f7d5..f49bb70dc7ffc 100644 --- a/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java +++ b/server/src/test/java/org/elasticsearch/script/ScriptServiceTests.java @@ -326,12 +326,12 @@ public void testMaxSizeLimit() throws Exception { scriptService.compile(new Script(ScriptType.INLINE, "test", "10+10", Collections.emptyMap()), randomFrom(contexts.values())); }); assertEquals("exceeded max allowed inline script size in bytes [4] with size [5] for script [10+10]", iae.getMessage()); - clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 6).build(), logger); + clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 6).build()); scriptService.compile(new Script(ScriptType.INLINE, "test", "10+10", Collections.emptyMap()), randomFrom(contexts.values())); - clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 5).build(), logger); + clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 5).build()); scriptService.compile(new Script(ScriptType.INLINE, "test", "10+10", Collections.emptyMap()), randomFrom(contexts.values())); iae = expectThrows(IllegalArgumentException.class, () -> { - clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 2).build(), logger); + clusterSettings.applySettings(Settings.builder().put(ScriptService.SCRIPT_MAX_SIZE_IN_BYTES.getKey(), 2).build()); }); assertEquals("script.max_size_in_bytes cannot be set to [2], stored script [test1] exceeds the new value with a size of [3]", iae.getMessage()); diff --git a/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java b/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java index c746b7d9c9be1..0badefd978bd3 100644 --- a/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java +++ b/test/framework/src/main/java/org/elasticsearch/test/IndexSettingsModule.java @@ -67,7 +67,7 @@ public static IndexSettings newIndexSettings(Index index, Settings indexSetting, if (setting.length > 0) { settingSet.addAll(Arrays.asList(setting)); } - return new IndexSettings(metaData, nodeSettings, new IndexScopedSettings(Settings.EMPTY, settingSet, index.getName())); + return new IndexSettings(metaData, nodeSettings, new IndexScopedSettings(Settings.EMPTY, settingSet)); } public static IndexSettings newIndexSettings(Index index, Settings settings, IndexScopedSettings indexScopedSettings) { @@ -85,7 +85,6 @@ public static IndexSettings newIndexSettings(final IndexMetaData indexMetaData, if (setting.length > 0) { settingSet.addAll(Arrays.asList(setting)); } - return new IndexSettings(indexMetaData, Settings.EMPTY, - new IndexScopedSettings(Settings.EMPTY, settingSet, indexMetaData.getIndex().getName())); + return new IndexSettings(indexMetaData, Settings.EMPTY, new IndexScopedSettings(Settings.EMPTY, settingSet)); } } diff --git a/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java b/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java index 579eda72a3d91..4dddb0af9b4c4 100644 --- a/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java +++ b/test/framework/src/main/java/org/elasticsearch/transport/AbstractSimpleTransportTestCase.java @@ -1059,7 +1059,7 @@ public String executor() { clusterSettingsA.applySettings(Settings.builder() .put(TransportSettings.TRACE_LOG_INCLUDE_SETTING.getKey(), includeSettings) .put(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.getKey(), excludeSettings) - .build(), logger); + .build()); MockLogAppender appender = new MockLogAppender(); try { diff --git a/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java b/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java index 9afe95df0fd2a..711caf3a6468c 100644 --- a/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java +++ b/x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/exporter/ExportersTests.java @@ -248,7 +248,7 @@ Map initExporters(Settings settings) { .put("xpack.monitoring.exporters._name0.use_ingest", true) .put("xpack.monitoring.exporters._name1.use_ingest", false) .build(); - clusterSettings.applySettings(update, logger); + clusterSettings.applySettings(update); assertThat(settingsHolder.get(), notNullValue()); settings = settingsHolder.get(); logger.info(settings); diff --git a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java index 91a7df83756a6..e3777fc854599 100644 --- a/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java +++ b/x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/transport/filter/IPFilterTests.java @@ -165,7 +165,7 @@ public void testThatProfilesAreUpdateable() throws Exception { .put("transport.profiles.client.xpack.security.filter.deny", "192.168.0.3").build(); Settings.Builder updatedSettingsBuilder = Settings.builder(); clusterSettings.updateDynamicSettings(newSettings, updatedSettingsBuilder, Settings.builder(), "test"); - clusterSettings.applySettings(updatedSettingsBuilder.build(), logger); + clusterSettings.applySettings(updatedSettingsBuilder.build()); assertAddressIsAllowed("127.0.0.1"); // when "localhost" is used, ES considers all local addresses see PatternRule#isLocalhost() assertAddressIsDenied(randomNonLocalIPv4Address()); diff --git a/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java b/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java index 902819d161554..e83f9154c5459 100644 --- a/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java +++ b/x-pack/plugin/watcher/src/test/java/org/elasticsearch/xpack/watcher/common/http/HttpClientTests.java @@ -718,7 +718,7 @@ public void testThatWhiteListReloadingWorks() throws Exception { assertThat(e.getMessage(), containsString("is not whitelisted")); Settings newSettings = Settings.builder().put(HttpSettings.HOSTS_WHITELIST.getKey(), getWebserverUri()).build(); - clusterSettings.applySettings(newSettings, logger); + clusterSettings.applySettings(newSettings); HttpResponse response = client.execute(request); assertThat(response.status(), is(200)); From 52dce94127da2047e51f8d76ed65cd25c9f49c85 Mon Sep 17 00:00:00 2001 From: kewei03 Date: Tue, 24 Dec 2019 15:06:43 +0800 Subject: [PATCH 6/7] make unit test more standard --- .../settings/AbstractScopedSettings.java | 4 -- .../common/settings/SettingTests.java | 46 +++++++++++++------ 2 files changed, 32 insertions(+), 18 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java index 76c1c1d52cb6a..99c651ef7df80 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/AbstractScopedSettings.java @@ -138,10 +138,6 @@ static boolean isValidAffixKey(String key) { return AFFIX_KEY_PATTERN.matcher(key).matches(); } - public Logger getLogger() { - return logger; - } - public Setting.Property getScope() { return this.scope; } diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java index 6df1eab6fb2a7..6b080145274c5 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java @@ -18,6 +18,8 @@ */ package org.elasticsearch.common.settings; +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.core.LogEvent; import org.apache.logging.log4j.core.appender.AbstractAppender; @@ -34,6 +36,8 @@ import org.elasticsearch.index.IndexSettings; import org.elasticsearch.monitor.jvm.JvmInfo; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.test.MockLogAppender; +import org.elasticsearch.test.junit.annotations.TestLogging; import java.util.Arrays; import java.util.Collections; @@ -1122,21 +1126,35 @@ public void testNonSecureSettingInKeystore() { assertThat(e.getMessage(), containsString("must be stored inside elasticsearch.yml")); } + @TestLogging(value="org.elasticsearch.common.settings.IndexScopedSettings:INFO", + reason="to ensure we log INFO-level messages from IndexScopedSettings") public void testLogSettingUpdate() throws Exception { - IndexMetaData metaData = newIndexMeta("index1", + final IndexMetaData metaData = newIndexMeta("index1", Settings.builder().put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "20s").build()); - IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY); - Logger logger = settings.getScopedSettings().getLogger(); - - MockAppender appender = new MockAppender("trace_appender"); - appender.start(); - Loggers.addAppender(logger, appender); - - settings.updateIndexMetaData(newIndexMeta("index1", - Settings.builder().put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "10s").build())); - - assertThat(appender.lastMementoMessage().getFormattedMessage(), equalTo("updating [index.refresh_interval] from [20s] to [10s]")); - assertThat(appender.getLoggerMaker(), equalTo(" [index1]")); - appender.stop(); + final IndexSettings settings = new IndexSettings(metaData, Settings.EMPTY); + + final MockLogAppender mockLogAppender = new MockLogAppender(); + mockLogAppender.addExpectation(new MockLogAppender.SeenEventExpectation( + "message", + "org.elasticsearch.common.settings.IndexScopedSettings", + Level.INFO, + "updating [index.refresh_interval] from [20s] to [10s]") { + @Override + public boolean innerMatch(LogEvent event) { + return event.getMarker().getName().equals(" [index1]"); + } + }); + mockLogAppender.start(); + final Logger logger = LogManager.getLogger(IndexScopedSettings.class); + try { + Loggers.addAppender(logger, mockLogAppender); + settings.updateIndexMetaData(newIndexMeta("index1", + Settings.builder().put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "10s").build())); + + mockLogAppender.assertAllExpectationsMatched(); + } finally { + Loggers.removeAppender(logger, mockLogAppender); + mockLogAppender.stop(); + } } } From 3ddc4e45e9d58f386aef06992eb29ff5619f15ab Mon Sep 17 00:00:00 2001 From: kewei03 Date: Fri, 3 Jan 2020 12:25:21 +0800 Subject: [PATCH 7/7] delete unused class --- .../common/settings/SettingTests.java | 24 ------------------- 1 file changed, 24 deletions(-) diff --git a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java index 6b080145274c5..889bfadb10ec7 100644 --- a/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java +++ b/server/src/test/java/org/elasticsearch/common/settings/SettingTests.java @@ -22,9 +22,6 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.core.LogEvent; -import org.apache.logging.log4j.core.appender.AbstractAppender; -import org.apache.logging.log4j.core.filter.RegexFilter; -import org.apache.logging.log4j.core.impl.MementoMessage; import org.elasticsearch.cluster.metadata.IndexMetaData; import org.elasticsearch.common.collect.Tuple; import org.elasticsearch.common.logging.Loggers; @@ -62,27 +59,6 @@ public class SettingTests extends ESTestCase { - public static class MockAppender extends AbstractAppender { - private LogEvent lastEvent; - - public MockAppender(final String name) throws IllegalAccessException { - super(name, RegexFilter.createFilter(".*(\n.*)*", new String[0], false, null, null), null); - } - - @Override - public void append(LogEvent event) { - lastEvent = event.toImmutable(); - } - - public MementoMessage lastMementoMessage() { - return (MementoMessage) lastEvent.getMessage(); - } - - public String getLoggerMaker() { - return lastEvent.getMarker().getName(); - } - } - public void testGet() { Setting booleanSetting = Setting.boolSetting("foo.bar", false, Property.Dynamic, Property.NodeScope); assertFalse(booleanSetting.get(Settings.EMPTY));