private static <T> AffixSetting<T> affixKeySetting(AffixKey key, Function<String, Setting<T>> delegateFactory, AffixSetting... dependencies) { Setting<T> delegate = delegateFactory.apply("_na_"); return new AffixSetting<>(key, delegate, delegateFactory, dependencies); }
/** * Configures the logging levels for loggers configured in the specified settings. * * @param settings the settings from which logger levels will be extracted */ private static void configureLoggerLevels(final Settings settings) { if (Loggers.LOG_DEFAULT_LEVEL_SETTING.exists(settings)) { final Level level = Loggers.LOG_DEFAULT_LEVEL_SETTING.get(settings); Loggers.setLevel(LogManager.getRootLogger(), level); } Loggers.LOG_LEVEL_SETTING.getAllConcreteSettings(settings) // do not set a log level for a logger named level (from the default log setting) .filter(s -> s.getKey().equals(Loggers.LOG_DEFAULT_LEVEL_SETTING.getKey()) == false).forEach(s -> { final Level level = s.get(settings); Loggers.setLevel(LogManager.getLogger(s.getKey().substring("logger.".length())), level); }); }
final Map<String, String> requireMap = INDEX_ROUTING_REQUIRE_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters requireFilters; if (requireMap.isEmpty()) { requireFilters = DiscoveryNodeFilters.buildFromKeyValue(AND, requireMap); Map<String, String> includeMap = INDEX_ROUTING_INCLUDE_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters includeFilters; if (includeMap.isEmpty()) { includeFilters = DiscoveryNodeFilters.buildFromKeyValue(OR, includeMap); Map<String, String> excludeMap = INDEX_ROUTING_EXCLUDE_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters excludeFilters; if (excludeMap.isEmpty()) { excludeFilters = DiscoveryNodeFilters.buildFromKeyValue(OR, excludeMap); Map<String, String> initialRecoveryMap = INDEX_ROUTING_INITIAL_RECOVERY_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters initialRecoveryFilters; if (initialRecoveryMap.isEmpty()) {
this.seedNodes = Collections.unmodifiableList(seedNodes); this.skipUnavailable = RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE .getConcreteSettingForNamespace(clusterAlias).get(settings); this.connectHandler = new ConnectHandler(); transportService.addConnectionListener(this);
Stream<Setting<List<InetSocketAddress>>> allConcreteSettings = REMOTE_CLUSTERS_SEEDS.getAllConcreteSettings(settings); return allConcreteSettings.collect( Collectors.toMap(REMOTE_CLUSTERS_SEEDS::getNamespace, concreteSetting -> { String clusterName = REMOTE_CLUSTERS_SEEDS.getNamespace(concreteSetting); List<DiscoveryNode> nodes = new ArrayList<>(); for (InetSocketAddress address : concreteSetting.get(settings)) {
final Map<String, String> requireMap = INDEX_ROUTING_REQUIRE_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters requireFilters; if (requireMap.isEmpty()) { requireFilters = DiscoveryNodeFilters.buildFromKeyValue(AND, requireMap); Map<String, String> includeMap = INDEX_ROUTING_INCLUDE_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters includeFilters; if (includeMap.isEmpty()) { includeFilters = DiscoveryNodeFilters.buildFromKeyValue(OR, includeMap); Map<String, String> excludeMap = INDEX_ROUTING_EXCLUDE_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters excludeFilters; if (excludeMap.isEmpty()) { excludeFilters = DiscoveryNodeFilters.buildFromKeyValue(OR, excludeMap); Map<String, String> initialRecoveryMap = INDEX_ROUTING_INITIAL_RECOVERY_GROUP_SETTING.getAsMap(settings); final DiscoveryNodeFilters initialRecoveryFilters; if (initialRecoveryMap.isEmpty()) {
.put(IndexMetaData.INDEX_ROUTING_INITIAL_RECOVERY_GROUP_SETTING.getKey() + "_id", Strings.arrayToCommaDelimitedString(nodesToAllocateOn.toArray()))
SettingUpdater<Map<SettingUpdater<A>, A>> affixUpdaterA = settingA.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {}); SettingUpdater<Map<SettingUpdater<B>, B>> affixUpdaterB = settingB.newAffixUpdater((a,b)-> {}, logger, (a,b)-> {});
private static class ListSetting<T> extends Setting<List<T>> { private final Function<Settings, List<String>> defaultStringValue; private ListSetting(String key, Function<Settings, List<String>> defaultStringValue, Function<String, List<T>> parser, Property... properties) { super(new ListKey(key), (s) -> Setting.arrayToParsableString(defaultStringValue.apply(s)), parser, properties); this.defaultStringValue = defaultStringValue; } @Override public String getRaw(Settings settings) { List<String> array = settings.getAsList(getKey(), null); return array == null ? defaultValue.apply(settings) : arrayToParsableString(array); } @Override boolean hasComplexMatcher() { return true; } @Override public void diff(Settings.Builder builder, Settings source, Settings defaultSettings) { if (exists(source) == false) { List<String> asList = defaultSettings.getAsList(getKey(), null); if (asList == null) { builder.putList(getKey(), defaultStringValue.apply(defaultSettings)); } else { builder.putList(getKey(), asList); } } } }
RemoteClusterConnection(Settings settings, String clusterAlias, List<Supplier<DiscoveryNode>> seedNodes, TransportService transportService, ConnectionManager connectionManager, int maxNumRemoteConnections, Predicate<DiscoveryNode> nodePredicate, String proxyAddress) { super(settings); this.transportService = transportService; this.maxNumRemoteConnections = maxNumRemoteConnections; this.nodePredicate = nodePredicate; this.clusterAlias = clusterAlias; ConnectionProfile.Builder builder = new ConnectionProfile.Builder(); builder.setConnectTimeout(TransportService.TCP_CONNECT_TIMEOUT.get(settings)); builder.setHandshakeTimeout(TransportService.TCP_CONNECT_TIMEOUT.get(settings)); builder.addConnections(6, TransportRequestOptions.Type.REG, TransportRequestOptions.Type.PING); // TODO make this configurable? builder.addConnections(0, // we don't want this to be used for anything else but search TransportRequestOptions.Type.BULK, TransportRequestOptions.Type.STATE, TransportRequestOptions.Type.RECOVERY); remoteProfile = builder.build(); connectedNodes = new ConnectedNodes(clusterAlias); this.seedNodes = Collections.unmodifiableList(seedNodes); this.skipUnavailable = RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE .getConcreteSettingForNamespace(clusterAlias).get(settings); this.connectHandler = new ConnectHandler(); this.threadPool = transportService.threadPool; this.connectionManager = connectionManager; connectionManager.addListener(this); // we register the transport service here as a listener to make sure we notify handlers on disconnect etc. connectionManager.addListener(transportService); this.proxyAddress = proxyAddress; }
@Override public Map<String, Tuple<A, B>> getValue(Settings current, Settings previous) { Map<String, Tuple<A, B>> map = new HashMap<>(); BiConsumer<String, A> aConsumer = (key, value) -> { assert map.containsKey(key) == false : "duplicate key: " + key; map.put(key, new Tuple<>(value, settingB.getConcreteSettingForNamespace(key).get(current))); }; BiConsumer<String, B> bConsumer = (key, value) -> { Tuple<A, B> abTuple = map.get(key); if (abTuple != null) { map.put(key, new Tuple<>(abTuple.v1(), value)); } else { assert settingA.getConcreteSettingForNamespace(key).get(current).equals(settingA.getConcreteSettingForNamespace (key).get(previous)) : "expected: " + settingA.getConcreteSettingForNamespace(key).get(current) + " but was " + settingA.getConcreteSettingForNamespace(key).get(previous); map.put(key, new Tuple<>(settingA.getConcreteSettingForNamespace(key).get(current), value)); } }; SettingUpdater<Map<SettingUpdater<A>, A>> affixUpdaterA = settingA.newAffixUpdater(aConsumer, logger, (a,b) ->{}); SettingUpdater<Map<SettingUpdater<B>, B>> affixUpdaterB = settingB.newAffixUpdater(bConsumer, logger, (a,b) ->{}); affixUpdaterA.apply(current, previous); affixUpdaterB.apply(current, previous); for (Map.Entry<String, Tuple<A, B>> entry : map.entrySet()) { validator.accept(entry.getKey(), entry.getValue()); } return Collections.unmodifiableMap(map); }
private Decision shouldIndexFilter(IndexMetaData indexMd, RoutingNode node, RoutingAllocation allocation) { if (indexMd.requireFilters() != null) { if (!indexMd.requireFilters().match(node.node())) { return allocation.decision(Decision.NO, NAME, "node does not match index setting [%s] filters [%s]", IndexMetaData.INDEX_ROUTING_REQUIRE_GROUP_PREFIX, indexMd.requireFilters()); } } if (indexMd.includeFilters() != null) { if (!indexMd.includeFilters().match(node.node())) { return allocation.decision(Decision.NO, NAME, "node does not match index setting [%s] filters [%s]", IndexMetaData.INDEX_ROUTING_INCLUDE_GROUP_PREFIX, indexMd.includeFilters()); } } if (indexMd.excludeFilters() != null) { if (indexMd.excludeFilters().match(node.node())) { return allocation.decision(Decision.NO, NAME, "node matches index setting [%s] filters [%s]", IndexMetaData.INDEX_ROUTING_EXCLUDE_GROUP_SETTING.getKey(), indexMd.excludeFilters()); } } return null; }
private Decision shouldIndexFilter(IndexMetaData indexMd, RoutingNode node, RoutingAllocation allocation) { if (indexMd.requireFilters() != null) { if (indexMd.requireFilters().match(node.node()) == false) { return allocation.decision(Decision.NO, NAME, "node does not match index setting [%s] filters [%s]", IndexMetaData.INDEX_ROUTING_REQUIRE_GROUP_PREFIX, indexMd.requireFilters()); } } if (indexMd.includeFilters() != null) { if (indexMd.includeFilters().match(node.node()) == false) { return allocation.decision(Decision.NO, NAME, "node does not match index setting [%s] filters [%s]", IndexMetaData.INDEX_ROUTING_INCLUDE_GROUP_PREFIX, indexMd.includeFilters()); } } if (indexMd.excludeFilters() != null) { if (indexMd.excludeFilters().match(node.node())) { return allocation.decision(Decision.NO, NAME, "node matches index setting [%s] filters [%s]", IndexMetaData.INDEX_ROUTING_EXCLUDE_GROUP_SETTING.getKey(), indexMd.excludeFilters()); } } return null; }
public ProfileSettings(Settings settings, String profileName) { this.profileName = profileName; isDefaultProfile = DEFAULT_PROFILE.equals(profileName); tcpKeepAlive = TCP_KEEP_ALIVE_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); tcpNoDelay = TCP_NO_DELAY_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); reuseAddress = TCP_REUSE_ADDRESS_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); sendBufferSize = TCP_SEND_BUFFER_SIZE_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); receiveBufferSize = TCP_RECEIVE_BUFFER_SIZE_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); List<String> profileBindHosts = BIND_HOST_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); bindHosts = (profileBindHosts.isEmpty() ? NetworkService.GLOBAL_NETWORK_BINDHOST_SETTING.get(settings) : profileBindHosts); publishHosts = PUBLISH_HOST_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); Setting<String> concretePort = PORT_PROFILE.getConcreteSettingForNamespace(profileName); if (concretePort.exists(settings) == false && isDefaultProfile == false) { throw new IllegalStateException("profile [" + profileName + "] has no port configured"); } portOrRange = PORT_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); publishPort = isDefaultProfile ? PUBLISH_PORT.get(settings) : PUBLISH_PORT_PROFILE.getConcreteSettingForNamespace(profileName).get(settings); } }
/** * Configures the logging levels for loggers configured in the specified settings. * * @param settings the settings from which logger levels will be extracted */ private static void configureLoggerLevels(final Settings settings) { if (Loggers.LOG_DEFAULT_LEVEL_SETTING.exists(settings)) { final Level level = Loggers.LOG_DEFAULT_LEVEL_SETTING.get(settings); Loggers.setLevel(LogManager.getRootLogger(), level); } Loggers.LOG_LEVEL_SETTING.getAllConcreteSettings(settings) // do not set a log level for a logger named level (from the default log setting) .filter(s -> s.getKey().equals(Loggers.LOG_DEFAULT_LEVEL_SETTING.getKey()) == false).forEach(s -> { final Level level = s.get(settings); Loggers.setLevel(LogManager.getLogger(s.getKey().substring("logger.".length())), level); }); }
/** * Configures the logging levels for loggers configured in the specified settings. * * @param settings the settings from which logger levels will be extracted */ private static void configureLoggerLevels(final Settings settings) { if (Loggers.LOG_DEFAULT_LEVEL_SETTING.exists(settings)) { final Level level = Loggers.LOG_DEFAULT_LEVEL_SETTING.get(settings); Loggers.setLevel(ESLoggerFactory.getRootLogger(), level); } Loggers.LOG_LEVEL_SETTING.getAllConcreteSettings(settings) // do not set a log level for a logger named level (from the default log setting) .filter(s -> s.getKey().equals(Loggers.LOG_DEFAULT_LEVEL_SETTING.getKey()) == false).forEach(s -> { final Level level = s.get(settings); Loggers.setLevel(ESLoggerFactory.getLogger(s.getKey().substring("logger.".length())), level); }); }
protected static Map<String, List<DiscoveryNode>> buildRemoteClustersSeeds(Settings settings) { Stream<Setting<List<InetSocketAddress>>> allConcreteSettings = REMOTE_CLUSTERS_SEEDS.getAllConcreteSettings(settings); return allConcreteSettings.collect( Collectors.toMap(REMOTE_CLUSTERS_SEEDS::getNamespace, concreteSetting -> { String clusterName = REMOTE_CLUSTERS_SEEDS.getNamespace(concreteSetting); List<DiscoveryNode> nodes = new ArrayList<>(); for (InetSocketAddress address : concreteSetting.get(settings)) { TransportAddress transportAddress = new InetSocketTransportAddress(address); DiscoveryNode node = new DiscoveryNode(clusterName + "#" + transportAddress.toString(), transportAddress, Version.CURRENT.minimumCompatibilityVersion()); nodes.add(node); } return nodes; })); }
private static Map<String, Tuple<String, List<Supplier<DiscoveryNode>>>> buildRemoteClustersDynamicConfig( final Settings settings, final Setting.AffixSetting<List<String>> seedsSetting) { final Stream<Setting<List<String>>> allConcreteSettings = seedsSetting.getAllConcreteSettings(settings); return allConcreteSettings.collect( Collectors.toMap(seedsSetting::getNamespace, concreteSetting -> { String clusterName = seedsSetting.getNamespace(concreteSetting); List<String> addresses = concreteSetting.get(settings); final boolean proxyMode = REMOTE_CLUSTERS_PROXY.getConcreteSettingForNamespace(clusterName).existsOrFallbackExists(settings); List<Supplier<DiscoveryNode>> nodes = new ArrayList<>(addresses.size()); for (String address : addresses) { nodes.add(() -> buildSeedNode(clusterName, address, proxyMode)); } return new Tuple<>(REMOTE_CLUSTERS_PROXY.getConcreteSettingForNamespace(clusterName).get(settings), nodes); })); }
@Override public Settings getValue(Settings current, Settings previous) { Settings.Builder builder = Settings.builder(); builder.put(current.filter(loggerPredicate)); for (String key : previous.keySet()) { if (loggerPredicate.test(key) && builder.keys().contains(key) == false) { if (Loggers.LOG_LEVEL_SETTING.getConcreteSetting(key).exists(settings) == false) { builder.putNull(key); } else { builder.put(key, Loggers.LOG_LEVEL_SETTING.getConcreteSetting(key).get(settings).toString()); } } } return builder.build(); }
private Stream<String> matchStream(Settings settings) { return settings.getAsMap().keySet().stream().filter((key) -> match(key)).map(settingKey -> key.getConcreteString(settingKey)); }