public Settings filter(Settings settings) { return filterSettings(patterns, settings); }
this.settingsFilter = new SettingsFilter(settingsFilterPattern);
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { ClusterRerouteRequest clusterRerouteRequest = createRequest(request); settingsFilter.addFilterSettingParams(request); if (clusterRerouteRequest.explain()) { request.params().put("explain", Boolean.TRUE.toString()); } // by default, return everything but metadata final String metric = request.param("metric"); if (metric == null) { request.params().put("metric", DEFAULT_METRICS); } return channel -> client.admin().cluster().reroute(clusterRerouteRequest, new RestToXContentListener<>(channel)); }
static ClusterGetSettingsResponse response( final ClusterState state, final boolean renderDefaults, final SettingsFilter settingsFilter, final ClusterSettings clusterSettings, final Settings settings) { return new ClusterGetSettingsResponse( settingsFilter.filter(state.metaData().persistentSettings()), settingsFilter.filter(state.metaData().transientSettings()), renderDefaults ? settingsFilter.filter(clusterSettings.diff(state.metaData().settings(), settings)) : Settings.EMPTY); }
/** * Registers a settings filter pattern that allows to filter out certain settings that for instance contain sensitive information * or if a setting is for internal purposes only. The given pattern must either be a valid settings key or a simple regexp pattern. */ private void registerSettingsFilter(String filter) { if (SettingsFilter.isValidPattern(filter) == false) { throw new IllegalArgumentException("filter [" + filter +"] is invalid must be either a key or a regex pattern"); } if (settingsFilterPattern.contains(filter)) { throw new IllegalArgumentException("filter [" + filter + "] has already been registered"); } settingsFilterPattern.add(filter); }
@Override protected void masterOperation(GetSettingsRequest request, ClusterState state, ActionListener<GetSettingsResponse> listener) { String[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request); ImmutableOpenMap.Builder<String, Settings> indexToSettingsBuilder = ImmutableOpenMap.builder(); for (String concreteIndex : concreteIndices) { IndexMetaData indexMetaData = state.getMetaData().index(concreteIndex); if (indexMetaData == null) { continue; } Settings settings = SettingsFilter.filterSettings(settingsFilter.getPatterns(), indexMetaData.getSettings()); if (request.humanReadable()) { settings = IndexMetaData.addHumanReadableSettings(settings); } if (!CollectionUtils.isEmpty(request.names())) { Settings.Builder settingsBuilder = Settings.builder(); for (Map.Entry<String, String> entry : settings.getAsMap().entrySet()) { if (Regex.simpleMatch(request.names(), entry.getKey())) { settingsBuilder.put(entry.getKey(), entry.getValue()); } } settings = settingsBuilder.build(); } indexToSettingsBuilder.put(concreteIndex, settings); } listener.onResponse(new GetSettingsResponse(indexToSettingsBuilder.build())); } }
@Inject public InternalAwsS3Service(Settings settings, SettingsFilter settingsFilter) { super(settings); settingsFilter.addFilter(new AwsSettingsFilter()); }
public NodeInfo info(boolean settings, boolean os, boolean process, boolean jvm, boolean threadPool, boolean transport, boolean http, boolean plugin, boolean ingest, boolean indices) { return new NodeInfo(Version.CURRENT, Build.CURRENT, transportService.getLocalNode(), settings ? settingsFilter.filter(this.settings) : null, os ? monitorService.osService().info() : null, process ? monitorService.processService().info() : null, jvm ? monitorService.jvmService().info() : null, threadPool ? this.threadPool.info() : null, transport ? transportService.info() : null, http ? (httpServerTransport == null ? null : httpServerTransport.info()) : null, plugin ? (pluginService == null ? null : pluginService.info()) : null, ingest ? (ingestService == null ? null : ingestService.info()) : null, indices ? indicesService.getTotalIndexingBufferBytes() : null ); }
public SettingsFilter(Collection<String> patterns) { for (String pattern : patterns) { if (isValidPattern(pattern) == false) { throw new IllegalArgumentException("invalid pattern: " + pattern); } } this.patterns = Collections.unmodifiableSet(new HashSet<>(patterns)); patternString = Strings.collectionToDelimitedString(patterns, ","); }
@Inject public AwsEc2Service(Settings settings, SettingsFilter settingsFilter, NetworkService networkService, DiscoveryNodeService discoveryNodeService) { super(settings); settingsFilter.addFilter(new AwsSettingsFilter()); // add specific ec2 name resolver networkService.addCustomNameResolver(new Ec2NameResolver(settings)); discoveryNodeService.addCustomAttributeProvider(new Ec2CustomNodeAttributes(settings)); }
public static Settings filterSettings(Params params, Settings settings) { String patterns = params.param(SETTINGS_FILTER_PARAM); final Settings filteredSettings; if (patterns != null && patterns.isEmpty() == false) { filteredSettings = filterSettings(Strings.commaDelimitedListToSet(patterns), settings); } else { filteredSettings = settings; } return filteredSettings; }
settingsFilter.addFilterSettingParams(request);
Settings indexSettings = settingsFilter.filter(indexMetaData.getSettings()); if (request.humanReadable()) { indexSettings = IndexMetaData.addHumanReadableSettings(indexSettings); Settings defaultSettings = settingsFilter.filter(indexScopedSettings.diff(indexSettings, Settings.EMPTY)); if (isFilteredRequest(request)) { defaultSettings = defaultSettings.filter(k -> Regex.simpleMatch(request.names(), k));
@Override protected XContentBuilder toXContent(ClusterRerouteRequest request, ClusterRerouteResponse response, XContentBuilder builder) throws IOException { builder.startObject(); builder.field(Fields.OK, true); builder.startObject("state"); response.getState().settingsFilter(new SettingsFilter(ImmutableSettings.settingsBuilder().build())).toXContent(builder, ToXContent.EMPTY_PARAMS); builder.endObject(); builder.endObject(); return builder; } }
/** * Registers a settings filter pattern that allows to filter out certain settings that for instance contain sensitive information * or if a setting is for internal purposes only. The given pattern must either be a valid settings key or a simple regexp pattern. */ private void registerSettingsFilter(String filter) { if (SettingsFilter.isValidPattern(filter) == false) { throw new IllegalArgumentException("filter [" + filter +"] is invalid must be either a key or a regex pattern"); } if (settingsFilterPattern.contains(filter)) { throw new IllegalArgumentException("filter [" + filter + "] has already been registered"); } settingsFilterPattern.add(filter); }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { Settings settings = SettingsFilter.filterSettings(params, this); if (!params.paramAsBoolean("flat_settings", false)) { for (Map.Entry<String, Object> entry : settings.getAsStructuredMap().entrySet()) { builder.field(entry.getKey(), entry.getValue()); } } else { for (Map.Entry<String, Object> entry : settings.settings.entrySet()) { builder.field(entry.getKey(), entry.getValue()); } } return builder; }
clusterStateRequest.customs(metrics.contains(ClusterState.Metric.CUSTOMS)); settingsFilter.addFilterSettingParams(request);
if (request.includeDefaults()) { Settings defaultIndexSettings = settingsFilter.filter(indexScopedSettings.diff(indexSettings, Settings.EMPTY)); defaultSettingsMapBuilder.put(index, defaultIndexSettings);
@Override protected XContentBuilder toXContent(NodesInfoRequest request, NodesInfoResponse response, XContentBuilder builder) throws IOException { response.settingsFilter(new SettingsFilter(ImmutableSettings.settingsBuilder().build())); builder.startObject(); builder.field(Fields.OK, true); response.toXContent(builder, ToXContent.EMPTY_PARAMS); builder.endObject(); return builder; } }
/** * Registers a settings filter pattern that allows to filter out certain settings that for instance contain sensitive information * or if a setting is for internal purposes only. The given pattern must either be a valid settings key or a simple regexp pattern. */ private void registerSettingsFilter(String filter) { if (SettingsFilter.isValidPattern(filter) == false) { throw new IllegalArgumentException("filter [" + filter +"] is invalid must be either a key or a regex pattern"); } if (settingsFilterPattern.contains(filter)) { throw new IllegalArgumentException("filter [" + filter + "] has already been registered"); } settingsFilterPattern.add(filter); }