From af9f738f134019f2e42a625e4e39385bc656394b Mon Sep 17 00:00:00 2001 From: Tim Brooks Date: Tue, 25 Feb 2020 14:33:26 -0700 Subject: [PATCH 1/2] Remove seeds depedency for remote cluster settings Currently 3 remote cluster settings (ping internval, skip unavailable, and compression) have a dependency on the seeds setting being comfigured. With proxy mode, it is now possible that these settings the seeds setting has not been configured. This commit removes this dependency and adds new validation for these settings. --- .../common/settings/ClusterSettings.java | 2 +- .../common/settings/Setting.java | 12 +++ .../transport/ProxyConnectionStrategy.java | 8 +- .../transport/RemoteClusterAware.java | 2 +- .../transport/RemoteClusterService.java | 50 ++++++++++-- .../transport/RemoteConnectionStrategy.java | 22 +++++- .../ProxyConnectionStrategyTests.java | 4 +- .../RemoteClusterConnectionTests.java | 2 +- .../transport/RemoteClusterServiceTests.java | 78 +++++++++++++------ 9 files changed, 139 insertions(+), 41 deletions(-) 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 4861cea792144..1b74e53803136 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java @@ -298,7 +298,7 @@ public void apply(Settings value, Settings current, Settings previous) { RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE, RemoteClusterService.REMOTE_CLUSTER_COMPRESS, RemoteConnectionStrategy.REMOTE_CONNECTION_MODE, - ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES, + ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS, ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS, ProxyConnectionStrategy.SERVER_NAME, SniffConnectionStrategy.REMOTE_CLUSTERS_PROXY, 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 05329882b7428..549f5ee755934 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/Setting.java +++ b/server/src/main/java/org/elasticsearch/common/settings/Setting.java @@ -1257,6 +1257,12 @@ public static Setting boolSetting(String key, Setting fallback return new Setting<>(key, fallbackSetting, b -> parseBoolean(b, key, isFiltered(properties)), properties); } + public static Setting boolSetting(String key, Setting fallbackSetting, Validator validator, + Property... properties) { + return new Setting<>(new SimpleKey(key), fallbackSetting, fallbackSetting::getRaw, b -> parseBoolean(b, key, + isFiltered(properties)), validator, properties); + } + public static Setting boolSetting(String key, boolean defaultValue, Validator validator, Property... properties) { return new Setting<>(key, Boolean.toString(defaultValue), b -> parseBoolean(b, key, isFiltered(properties)), validator, properties); } @@ -1626,6 +1632,12 @@ public static Setting timeSetting(String key, Setting fall return new Setting<>(key, fallbackSetting, (s) -> TimeValue.parseTimeValue(s, key), properties); } + public static Setting timeSetting(String key, Setting fallBackSetting, Validator validator, + Property... properties) { + return new Setting<>(new SimpleKey(key), fallBackSetting, fallBackSetting::getRaw, (s) -> TimeValue.parseTimeValue(s, key), + validator, properties); + } + public static Setting positiveTimeSetting(String key, TimeValue defaultValue, Property... properties) { return timeSetting(key, defaultValue, TimeValue.timeValueMillis(0), properties); } diff --git a/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java b/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java index cd3983781d0f8..bd9971749009a 100644 --- a/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java +++ b/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java @@ -53,7 +53,7 @@ public class ProxyConnectionStrategy extends RemoteConnectionStrategy { /** * The remote address for the proxy. The connections will be opened to the configured address. */ - public static final Setting.AffixSetting REMOTE_CLUSTER_ADDRESSES = Setting.affixKeySetting( + public static final Setting.AffixSetting REMOTE_CLUSTER_ADDRESS = Setting.affixKeySetting( "cluster.remote.", "proxy_address", (ns, key) -> Setting.simpleString(key, new StrategyValidator<>(ns, key, ConnectionStrategy.PROXY, s -> { @@ -99,7 +99,7 @@ public class ProxyConnectionStrategy extends RemoteConnectionStrategy { transportService, connectionManager, REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(settings), - REMOTE_CLUSTER_ADDRESSES.getConcreteSettingForNamespace(clusterAlias).get(settings), + REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings), SERVER_NAME.getConcreteSettingForNamespace(clusterAlias).get(settings)); } @@ -141,7 +141,7 @@ public class ProxyConnectionStrategy extends RemoteConnectionStrategy { } static Stream> enablementSettings() { - return Stream.of(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES); + return Stream.of(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS); } static Writeable.Reader infoReader() { @@ -155,7 +155,7 @@ protected boolean shouldOpenMoreConnections() { @Override protected boolean strategyMustBeRebuilt(Settings newSettings) { - String address = REMOTE_CLUSTER_ADDRESSES.getConcreteSettingForNamespace(clusterAlias).get(newSettings); + String address = REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(newSettings); int numOfSockets = REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(newSettings); return numOfSockets != maxNumConnections || configuredAddress.equals(address) == false; } diff --git a/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java b/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java index 08c819c70a47c..da9e4fe9f1f94 100644 --- a/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java +++ b/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java @@ -109,7 +109,7 @@ public void listenForUpdates(ClusterSettings clusterSettings) { SniffConnectionStrategy.REMOTE_CLUSTERS_PROXY, SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS, SniffConnectionStrategy.REMOTE_NODE_CONNECTIONS, - ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES, + ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS, ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS, ProxyConnectionStrategy.SERVER_NAME); clusterSettings.addAffixGroupUpdateConsumer(remoteClusterSettings, this::validateAndUpdateRemoteCluster); diff --git a/server/src/main/java/org/elasticsearch/transport/RemoteClusterService.java b/server/src/main/java/org/elasticsearch/transport/RemoteClusterService.java index 779d4deacd45a..1d6b6a12af0c0 100644 --- a/server/src/main/java/org/elasticsearch/transport/RemoteClusterService.java +++ b/server/src/main/java/org/elasticsearch/transport/RemoteClusterService.java @@ -40,8 +40,10 @@ import java.io.Closeable; import java.io.IOException; +import java.util.Arrays; import java.util.Collection; import java.util.HashMap; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; @@ -95,24 +97,24 @@ public final class RemoteClusterService extends RemoteClusterAware implements Cl Setting.affixKeySetting( "cluster.remote.", "skip_unavailable", - key -> boolSetting( + (ns, key) -> boolSetting( key, false, + new RemoteConnectionEnabled<>(ns, key), Setting.Property.Dynamic, - Setting.Property.NodeScope), - () -> SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS); + Setting.Property.NodeScope)); public static final Setting.AffixSetting REMOTE_CLUSTER_PING_SCHEDULE = Setting.affixKeySetting( "cluster.remote.", "transport.ping_schedule", - key -> timeSetting(key, TransportSettings.PING_SCHEDULE, Setting.Property.Dynamic, Setting.Property.NodeScope), - () -> SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS); + (ns, key) -> timeSetting(key, TransportSettings.PING_SCHEDULE, new RemoteConnectionEnabled<>(ns, key), + Setting.Property.Dynamic, Setting.Property.NodeScope)); public static final Setting.AffixSetting REMOTE_CLUSTER_COMPRESS = Setting.affixKeySetting( "cluster.remote.", "transport.compress", - key -> boolSetting(key, TransportSettings.TRANSPORT_COMPRESS, Setting.Property.Dynamic, Setting.Property.NodeScope), - () -> SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS); + (ns, key) -> boolSetting(key, TransportSettings.TRANSPORT_COMPRESS, + new RemoteConnectionEnabled<>(ns, key), Setting.Property.Dynamic, Setting.Property.NodeScope)); private final TransportService transportService; private final Map remoteClusters = ConcurrentCollections.newConcurrentMap(); @@ -386,4 +388,38 @@ public Client getRemoteClusterClient(ThreadPool threadPool, String clusterAlias) Collection getConnections() { return remoteClusters.values(); } + + private static class RemoteConnectionEnabled implements Setting.Validator { + + private final String clusterAlias; + private final String key; + + private RemoteConnectionEnabled(String clusterAlias, String key) { + this.clusterAlias = clusterAlias; + this.key = key; + } + + @Override + public void validate(T value) { + } + + @Override + public void validate(T value, Map, Object> settings, boolean isPresent) { + if (isPresent && RemoteConnectionStrategy.isConnectionEnabled(clusterAlias, settings) == false) { + throw new IllegalArgumentException("Cannot configure setting [" + key + "] if remote cluster is not enabled."); + } + } + + @Override + public Iterator> settings() { + return Stream.concat(Stream.of(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias)), + settingsStream()).iterator(); + } + + private Stream> settingsStream() { + return Arrays.stream(RemoteConnectionStrategy.ConnectionStrategy.values()) + .flatMap(strategy -> strategy.getEnablementSettings().get()) + .map(as -> as.getConcreteSettingForNamespace(clusterAlias)); + } + }; } diff --git a/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java b/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java index d198224d0de33..bd9c524af1717 100644 --- a/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java +++ b/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java @@ -88,6 +88,10 @@ public int getNumberOfChannels() { return numberOfChannels; } + public Supplier>> getEnablementSettings() { + return enablementSettings; + } + public Writeable.Reader getReader() { return reader.get(); } @@ -149,7 +153,7 @@ static RemoteConnectionStrategy buildStrategy(String clusterAlias, TransportServ static Set getRemoteClusters(Settings settings) { final Stream> enablementSettings = Arrays.stream(ConnectionStrategy.values()) - .flatMap(strategy -> strategy.enablementSettings.get()); + .flatMap(strategy -> strategy.getEnablementSettings().get()); return enablementSettings.flatMap(s -> getClusterAlias(settings, s)).collect(Collectors.toSet()); } @@ -159,7 +163,21 @@ public static boolean isConnectionEnabled(String clusterAlias, Settings settings List seeds = SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias).get(settings); return seeds.isEmpty() == false; } else { - String address = ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES.getConcreteSettingForNamespace(clusterAlias).get(settings); + String address = ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings); + return Strings.isEmpty(address) == false; + } + } + + @SuppressWarnings("unchecked") + public static boolean isConnectionEnabled(String clusterAlias, Map, Object> settings) { + ConnectionStrategy mode = (ConnectionStrategy) settings.get(REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias)); + if (mode.equals(ConnectionStrategy.SNIFF)) { + List seeds = (List) settings.get(SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS + .getConcreteSettingForNamespace(clusterAlias)); + return seeds.isEmpty() == false; + } else { + String address = (String) settings.get(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS + .getConcreteSettingForNamespace(clusterAlias)); return Strings.isEmpty(address) == false; } } diff --git a/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java b/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java index 47ba6b17205d1..62c8a95ee4815 100644 --- a/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java +++ b/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java @@ -291,7 +291,7 @@ public void testProxyStrategyWillNeedToBeRebuiltIfNumOfSocketsOrAddressesChange( Setting modeSetting = RemoteConnectionStrategy.REMOTE_CONNECTION_MODE .getConcreteSettingForNamespace("cluster-alias"); - Setting addressesSetting = ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES + Setting addressesSetting = ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS .getConcreteSettingForNamespace("cluster-alias"); Setting socketConnections = ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS .getConcreteSettingForNamespace("cluster-alias"); @@ -320,7 +320,7 @@ public void testProxyStrategyWillNeedToBeRebuiltIfNumOfSocketsOrAddressesChange( public void testModeSettingsCannotBeUsedWhenInDifferentMode() { List, String>> restrictedSettings = Arrays.asList( - new Tuple<>(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES, "192.168.0.1:8080"), + new Tuple<>(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS, "192.168.0.1:8080"), new Tuple<>(ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS, "3")); RemoteConnectionStrategy.ConnectionStrategy sniff = RemoteConnectionStrategy.ConnectionStrategy.SNIFF; diff --git a/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java b/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java index bda5fe58d6571..ae6851d685a9a 100644 --- a/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java +++ b/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java @@ -590,7 +590,7 @@ private Settings buildRandomSettings(String clusterAlias, List addresses private static Settings buildProxySettings(String clusterAlias, List addresses) { Settings.Builder builder = Settings.builder(); - builder.put(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES.getConcreteSettingForNamespace(clusterAlias).getKey(), + builder.put(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).getKey(), addresses.get(0)); builder.put(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).getKey(), "proxy"); return builder.build(); diff --git a/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java b/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java index e0e9b69ae29f8..7a7b7a7f24c84 100644 --- a/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java +++ b/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java @@ -85,7 +85,7 @@ public void testSettingsAreRegistered() { assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(SniffConnectionStrategy.REMOTE_CONNECTIONS_PER_CLUSTER)); assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS)); assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(SniffConnectionStrategy.REMOTE_NODE_CONNECTIONS)); - assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESSES)); + assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS)); assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS)); } @@ -664,40 +664,72 @@ public void onFailure(Exception e) { public void testRemoteClusterSkipIfDisconnectedSetting() { { Settings settings = Settings.builder() - .put("cluster.remote.foo.skip_unavailable", true) - .put("cluster.remote.bar.skip_unavailable", false).build(); + .put("cluster.remote.foo.seeds", "127.0.0.1:9300") + .put("cluster.remote.foo.skip_unavailable", true).build(); RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE.getAllConcreteSettings(settings).forEach(setting -> setting.get(settings)); } { - Settings brokenSettings = Settings.builder() + Settings brokenSettingsDependency = Settings.builder() + .put("cluster.remote.foo.skip_unavailable", true).build(); + IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> + RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE.getAllConcreteSettings(brokenSettingsDependency) + .forEach(setting -> setting.get(brokenSettingsDependency))); + assertEquals("Cannot configure setting [cluster.remote.foo.skip_unavailable] if remote cluster is not enabled.", + iae.getMessage()); + } + { + Settings brokenSettingsType = Settings.builder() .put("cluster.remote.foo.skip_unavailable", "broken").build(); - expectThrows(IllegalArgumentException.class, () -> - RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE.getAllConcreteSettings(brokenSettings) - .forEach(setting -> setting.get(brokenSettings))); + IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> + RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE.getAllConcreteSettings(brokenSettingsType) + .forEach(setting -> setting.get(brokenSettingsType))); + } + + { + Settings settings = Settings.builder() + .put("cluster.remote.foo.mode", "proxy") + .put("cluster.remote.foo.proxy_address", "127.0.0.1:9300") + .put("cluster.remote.foo.transport.ping_schedule", "5s").build(); + RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getAllConcreteSettings(settings).forEach(setting -> setting.get(settings)); + } + { + Settings brokenSettingsDependency = Settings.builder() + .put("cluster.remote.foo.proxy_address", "127.0.0.1:9300") + .put("cluster.remote.foo.transport.ping_schedule", "5s").build(); + IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> + RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getAllConcreteSettings(brokenSettingsDependency) + .forEach(setting -> setting.get(brokenSettingsDependency))); + assertEquals("Cannot configure setting [cluster.remote.foo.transport.ping_schedule] if remote cluster is not enabled.", + iae.getMessage()); + } + + { + Settings settings = Settings.builder() + .put("cluster.remote.foo.seeds", "127.0.0.1:9300") + .put("cluster.remote.foo.transport.compress", false).build(); + RemoteClusterService.REMOTE_CLUSTER_COMPRESS.getAllConcreteSettings(settings).forEach(setting -> setting.get(settings)); + } + { + Settings brokenSettingsDependency = Settings.builder() + .put("cluster.remote.foo.proxy_address", "127.0.0.1:9300") + .put("cluster.remote.foo.transport.compress", true).build(); + IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> + RemoteClusterService.REMOTE_CLUSTER_COMPRESS.getAllConcreteSettings(brokenSettingsDependency) + .forEach(setting -> setting.get(brokenSettingsDependency))); + assertEquals("Cannot configure setting [cluster.remote.foo.transport.compress] if remote cluster is not enabled.", + iae.getMessage()); } AbstractScopedSettings service = new ClusterSettings(Settings.EMPTY, new HashSet<>(Arrays.asList(SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS, RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE))); { - Settings settings = Settings.builder().put("cluster.remote.foo.skip_unavailable", randomBoolean()).build(); - IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> service.validate(settings, true)); - assertEquals("missing required setting [cluster.remote.foo.seeds] for setting [cluster.remote.foo.skip_unavailable]", + Settings brokenSettingsDependency = Settings.builder().put("cluster.remote.foo.skip_unavailable", randomBoolean()).build(); + IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, + () -> service.validate(brokenSettingsDependency, true)); + assertEquals("Cannot configure setting [cluster.remote.foo.skip_unavailable] if remote cluster is not enabled.", iae.getMessage()); } - { - try (MockTransportService remoteSeedTransport = startTransport("seed", new CopyOnWriteArrayList<>(), Version.CURRENT)) { - String seed = remoteSeedTransport.getLocalDiscoNode().getAddress().toString(); - service.validate(Settings.builder().put("cluster.remote.foo.skip_unavailable", randomBoolean()) - .put("cluster.remote.foo.seeds", seed).build(), true); - service.validate(Settings.builder().put("cluster.remote.foo.seeds", seed).build(), true); - - AbstractScopedSettings service2 = new ClusterSettings(Settings.builder().put("cluster.remote.foo.seeds", seed).build(), - new HashSet<>(Arrays.asList(SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS, - RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE))); - service2.validate(Settings.builder().put("cluster.remote.foo.skip_unavailable", randomBoolean()).build(), false); - } - } } public void testReconnectWhenStrategySettingsUpdated() throws Exception { From 66293a88bb6588bd979a70835201da1daf5258db Mon Sep 17 00:00:00 2001 From: Tim Brooks Date: Tue, 25 Feb 2020 15:14:04 -0700 Subject: [PATCH 2/2] Fix tests --- .../search/CrossClusterSearchUnavailableClusterIT.java | 8 ++++---- .../elasticsearch/common/settings/ClusterSettings.java | 2 +- .../elasticsearch/transport/ProxyConnectionStrategy.java | 8 ++++---- .../org/elasticsearch/transport/RemoteClusterAware.java | 2 +- .../elasticsearch/transport/RemoteConnectionStrategy.java | 4 ++-- .../transport/ProxyConnectionStrategyTests.java | 4 ++-- .../transport/RemoteClusterConnectionTests.java | 2 +- .../transport/RemoteClusterServiceTests.java | 2 +- .../transport/RemoteConnectionStrategyTests.java | 3 +++ 9 files changed, 19 insertions(+), 16 deletions(-) diff --git a/qa/ccs-unavailable-clusters/src/test/java/org/elasticsearch/search/CrossClusterSearchUnavailableClusterIT.java b/qa/ccs-unavailable-clusters/src/test/java/org/elasticsearch/search/CrossClusterSearchUnavailableClusterIT.java index 2bf0eae138135..d19cf3ebd974b 100644 --- a/qa/ccs-unavailable-clusters/src/test/java/org/elasticsearch/search/CrossClusterSearchUnavailableClusterIT.java +++ b/qa/ccs-unavailable-clusters/src/test/java/org/elasticsearch/search/CrossClusterSearchUnavailableClusterIT.java @@ -248,8 +248,8 @@ public void testSkipUnavailableDependsOnSeeds() throws IOException { () -> client().performRequest(request)); assertEquals(400, responseException.getResponse().getStatusLine().getStatusCode()); assertThat(responseException.getMessage(), - containsString("missing required setting [cluster.remote.remote1.seeds] " + - "for setting [cluster.remote.remote1.skip_unavailable]")); + containsString("Cannot configure setting [cluster.remote.remote1.skip_unavailable] if remote cluster is " + + "not enabled.")); } Map settingsMap = new HashMap<>(); @@ -264,8 +264,8 @@ public void testSkipUnavailableDependsOnSeeds() throws IOException { ResponseException responseException = expectThrows(ResponseException.class, () -> client().performRequest(request)); assertEquals(400, responseException.getResponse().getStatusLine().getStatusCode()); - assertThat(responseException.getMessage(), containsString("missing required setting [cluster.remote.remote1.seeds] " + - "for setting [cluster.remote.remote1.skip_unavailable]")); + assertThat(responseException.getMessage(), containsString("Cannot configure setting " + + "[cluster.remote.remote1.skip_unavailable] if remote cluster is not enabled.")); } if (randomBoolean()) { 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 1b74e53803136..42e9d121aa850 100644 --- a/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java +++ b/server/src/main/java/org/elasticsearch/common/settings/ClusterSettings.java @@ -298,7 +298,7 @@ public void apply(Settings value, Settings current, Settings previous) { RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE, RemoteClusterService.REMOTE_CLUSTER_COMPRESS, RemoteConnectionStrategy.REMOTE_CONNECTION_MODE, - ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS, + ProxyConnectionStrategy.PROXY_ADDRESS, ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS, ProxyConnectionStrategy.SERVER_NAME, SniffConnectionStrategy.REMOTE_CLUSTERS_PROXY, diff --git a/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java b/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java index bd9971749009a..5ce6de7998801 100644 --- a/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java +++ b/server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java @@ -53,7 +53,7 @@ public class ProxyConnectionStrategy extends RemoteConnectionStrategy { /** * The remote address for the proxy. The connections will be opened to the configured address. */ - public static final Setting.AffixSetting REMOTE_CLUSTER_ADDRESS = Setting.affixKeySetting( + public static final Setting.AffixSetting PROXY_ADDRESS = Setting.affixKeySetting( "cluster.remote.", "proxy_address", (ns, key) -> Setting.simpleString(key, new StrategyValidator<>(ns, key, ConnectionStrategy.PROXY, s -> { @@ -99,7 +99,7 @@ public class ProxyConnectionStrategy extends RemoteConnectionStrategy { transportService, connectionManager, REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(settings), - REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings), + PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings), SERVER_NAME.getConcreteSettingForNamespace(clusterAlias).get(settings)); } @@ -141,7 +141,7 @@ public class ProxyConnectionStrategy extends RemoteConnectionStrategy { } static Stream> enablementSettings() { - return Stream.of(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS); + return Stream.of(ProxyConnectionStrategy.PROXY_ADDRESS); } static Writeable.Reader infoReader() { @@ -155,7 +155,7 @@ protected boolean shouldOpenMoreConnections() { @Override protected boolean strategyMustBeRebuilt(Settings newSettings) { - String address = REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(newSettings); + String address = PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(newSettings); int numOfSockets = REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(newSettings); return numOfSockets != maxNumConnections || configuredAddress.equals(address) == false; } diff --git a/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java b/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java index da9e4fe9f1f94..258910bb55716 100644 --- a/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java +++ b/server/src/main/java/org/elasticsearch/transport/RemoteClusterAware.java @@ -109,7 +109,7 @@ public void listenForUpdates(ClusterSettings clusterSettings) { SniffConnectionStrategy.REMOTE_CLUSTERS_PROXY, SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS, SniffConnectionStrategy.REMOTE_NODE_CONNECTIONS, - ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS, + ProxyConnectionStrategy.PROXY_ADDRESS, ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS, ProxyConnectionStrategy.SERVER_NAME); clusterSettings.addAffixGroupUpdateConsumer(remoteClusterSettings, this::validateAndUpdateRemoteCluster); diff --git a/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java b/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java index bd9c524af1717..ad6b80ba49b9e 100644 --- a/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java +++ b/server/src/main/java/org/elasticsearch/transport/RemoteConnectionStrategy.java @@ -163,7 +163,7 @@ public static boolean isConnectionEnabled(String clusterAlias, Settings settings List seeds = SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias).get(settings); return seeds.isEmpty() == false; } else { - String address = ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings); + String address = ProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings); return Strings.isEmpty(address) == false; } } @@ -176,7 +176,7 @@ public static boolean isConnectionEnabled(String clusterAlias, Map, O .getConcreteSettingForNamespace(clusterAlias)); return seeds.isEmpty() == false; } else { - String address = (String) settings.get(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS + String address = (String) settings.get(ProxyConnectionStrategy.PROXY_ADDRESS .getConcreteSettingForNamespace(clusterAlias)); return Strings.isEmpty(address) == false; } diff --git a/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java b/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java index 62c8a95ee4815..ee9d98d07b3ec 100644 --- a/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java +++ b/server/src/test/java/org/elasticsearch/transport/ProxyConnectionStrategyTests.java @@ -291,7 +291,7 @@ public void testProxyStrategyWillNeedToBeRebuiltIfNumOfSocketsOrAddressesChange( Setting modeSetting = RemoteConnectionStrategy.REMOTE_CONNECTION_MODE .getConcreteSettingForNamespace("cluster-alias"); - Setting addressesSetting = ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS + Setting addressesSetting = ProxyConnectionStrategy.PROXY_ADDRESS .getConcreteSettingForNamespace("cluster-alias"); Setting socketConnections = ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS .getConcreteSettingForNamespace("cluster-alias"); @@ -320,7 +320,7 @@ public void testProxyStrategyWillNeedToBeRebuiltIfNumOfSocketsOrAddressesChange( public void testModeSettingsCannotBeUsedWhenInDifferentMode() { List, String>> restrictedSettings = Arrays.asList( - new Tuple<>(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS, "192.168.0.1:8080"), + new Tuple<>(ProxyConnectionStrategy.PROXY_ADDRESS, "192.168.0.1:8080"), new Tuple<>(ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS, "3")); RemoteConnectionStrategy.ConnectionStrategy sniff = RemoteConnectionStrategy.ConnectionStrategy.SNIFF; diff --git a/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java b/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java index ae6851d685a9a..f8a4fe4b9429b 100644 --- a/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java +++ b/server/src/test/java/org/elasticsearch/transport/RemoteClusterConnectionTests.java @@ -590,7 +590,7 @@ private Settings buildRandomSettings(String clusterAlias, List addresses private static Settings buildProxySettings(String clusterAlias, List addresses) { Settings.Builder builder = Settings.builder(); - builder.put(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS.getConcreteSettingForNamespace(clusterAlias).getKey(), + builder.put(ProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).getKey(), addresses.get(0)); builder.put(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).getKey(), "proxy"); return builder.build(); diff --git a/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java b/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java index 7a7b7a7f24c84..9b35f8367914c 100644 --- a/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java +++ b/server/src/test/java/org/elasticsearch/transport/RemoteClusterServiceTests.java @@ -85,7 +85,7 @@ public void testSettingsAreRegistered() { assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(SniffConnectionStrategy.REMOTE_CONNECTIONS_PER_CLUSTER)); assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS)); assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(SniffConnectionStrategy.REMOTE_NODE_CONNECTIONS)); - assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(ProxyConnectionStrategy.REMOTE_CLUSTER_ADDRESS)); + assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(ProxyConnectionStrategy.PROXY_ADDRESS)); assertTrue(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(ProxyConnectionStrategy.REMOTE_SOCKET_CONNECTIONS)); } diff --git a/server/src/test/java/org/elasticsearch/transport/RemoteConnectionStrategyTests.java b/server/src/test/java/org/elasticsearch/transport/RemoteConnectionStrategyTests.java index c9ce9a4c9a6df..cb4a4fb7189bf 100644 --- a/server/src/test/java/org/elasticsearch/transport/RemoteConnectionStrategyTests.java +++ b/server/src/test/java/org/elasticsearch/transport/RemoteConnectionStrategyTests.java @@ -36,6 +36,7 @@ public void testStrategyChangeMeansThatStrategyMustBeRebuilt() { RemoteConnectionStrategy.ConnectionStrategy.PROXY); Settings newSettings = Settings.builder() .put(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace("cluster-alias").getKey(), "sniff") + .put(SniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace("cluster-alias").getKey(), "127.0.0.1:9300") .build(); assertTrue(first.shouldRebuildConnection(newSettings)); } @@ -47,6 +48,7 @@ public void testSameStrategyChangeMeansThatStrategyDoesNotNeedToBeRebuilt() { RemoteConnectionStrategy.ConnectionStrategy.PROXY); Settings newSettings = Settings.builder() .put(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace("cluster-alias").getKey(), "proxy") + .put(ProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace("cluster-alias").getKey(), "127.0.0.1:9300") .build(); assertFalse(first.shouldRebuildConnection(newSettings)); } @@ -61,6 +63,7 @@ public void testChangeInConnectionProfileMeansTheStrategyMustBeRebuilt() { Settings.Builder newBuilder = Settings.builder(); newBuilder.put(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace("cluster-alias").getKey(), "proxy"); + newBuilder.put(ProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace("cluster-alias").getKey(), "127.0.0.1:9300"); if (randomBoolean()) { newBuilder.put(RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getConcreteSettingForNamespace("cluster-alias").getKey(), TimeValue.timeValueSeconds(5));