Java SettingsFilter类代码示例

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
NodeService(Settings settings, ThreadPool threadPool, MonitorService monitorService, Discovery discovery,
                   TransportService transportService, IndicesService indicesService, PluginsService pluginService,
                   CircuitBreakerService circuitBreakerService, ScriptService scriptService,
                   @Nullable HttpServerTransport httpServerTransport, IngestService ingestService, ClusterService clusterService,
                   SettingsFilter settingsFilter) {
    super(settings);
    this.threadPool = threadPool;
    this.monitorService = monitorService;
    this.transportService = transportService;
    this.indicesService = indicesService;
    this.discovery = discovery;
    this.pluginService = pluginService;
    this.circuitBreakerService = circuitBreakerService;
    this.httpServerTransport = httpServerTransport;
    this.ingestService = ingestService;
    this.settingsFilter = settingsFilter;
    this.scriptService = scriptService;
    clusterService.addStateApplier(ingestService.getPipelineStore());
    clusterService.addStateApplier(ingestService.getPipelineExecutionService());
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
public void testSettingsFiltering() throws IOException {
    AzureRepositoryPlugin p = new AzureRepositoryPlugin();
    SettingsModule module = new SettingsModule(Settings.EMPTY, p.getSettings(), p.getSettingsFilter());
    SettingsFilter settingsFilter = ModuleTestCase.bindAndGetInstance(module, SettingsFilter.class);

    // Test using direct filtering
    Settings filteredSettings = settingsFilter.filter(settings);
    assertThat(filteredSettings.getAsMap().keySet(), contains("cloud.azure.storage.azure1.default"));

    // Test using toXContent filtering
    RestRequest request = new FakeRestRequest();
    settingsFilter.addFilterSettingParams(request);
    XContentBuilder xContentBuilder = XContentBuilder.builder(JsonXContent.jsonXContent);
    xContentBuilder.startObject();
    settings.toXContent(xContentBuilder, request);
    xContentBuilder.endObject();
    String filteredSettingsString = xContentBuilder.string();
    filteredSettings = Settings.builder().loadFromSource(filteredSettingsString, xContentBuilder.contentType()).build();
    assertThat(filteredSettings.getAsMap().keySet(), contains("cloud.azure.storage.azure1.default"));
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    return Arrays.asList(
            new RestSearchTemplateAction(settings, restController),
            new RestMultiSearchTemplateAction(settings, restController),
            new RestGetSearchTemplateAction(settings, restController),
            new RestPutSearchTemplateAction(settings, restController),
            new RestDeleteSearchTemplateAction(settings, restController),
            new RestRenderSearchTemplateAction(settings, restController));
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    return Arrays.asList(
            new RestReindexAction(settings, restController),
            new RestUpdateByQueryAction(settings, restController),
            new RestDeleteByQueryAction(settings, restController),
            new RestRethrottleAction(settings, restController, nodesInCluster));
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    return Arrays.asList(
            new RestNoopBulkAction(settings, restController),
            new RestNoopSearchAction(settings, restController));
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
public RestGetSettingsAction(Settings settings, RestController controller, IndexScopedSettings indexScopedSettings,
        final SettingsFilter settingsFilter) {
    super(settings);
    this.indexScopedSettings = indexScopedSettings;
    controller.registerHandler(GET, "/{index}/_settings/{name}", this);
    controller.registerHandler(GET, "/_settings/{name}", this);
    controller.registerHandler(GET, "/{index}/_setting/{name}", this);
    this.settingsFilter = settingsFilter;
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
public RestGetIndicesAction(
        final Settings settings,
        final RestController controller,
        final IndexScopedSettings indexScopedSettings,
        final SettingsFilter settingsFilter) {
    super(settings);
    this.indexScopedSettings = indexScopedSettings;
    controller.registerHandler(GET, "/{index}", this);
    controller.registerHandler(HEAD, "/{index}", this);
    controller.registerHandler(GET, "/{index}/{type}", this);
    this.settingsFilter = settingsFilter;
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
public RestNodesInfoAction(Settings settings, RestController controller, SettingsFilter settingsFilter) {
    super(settings);
    controller.registerHandler(GET, "/_nodes", this);
    // this endpoint is used for metrics, not for node IDs, like /_nodes/fs
    controller.registerHandler(GET, "/_nodes/{nodeId}", this);
    controller.registerHandler(GET, "/_nodes/{nodeId}/{metrics}", this);
    // added this endpoint to be aligned with stats
    controller.registerHandler(GET, "/_nodes/{nodeId}/info/{metrics}", this);

    this.settingsFilter = settingsFilter;
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
public RestClusterStateAction(Settings settings, RestController controller, SettingsFilter settingsFilter) {
    super(settings);
    controller.registerHandler(RestRequest.Method.GET, "/_cluster/state", this);
    controller.registerHandler(RestRequest.Method.GET, "/_cluster/state/{metric}", this);
    controller.registerHandler(RestRequest.Method.GET, "/_cluster/state/{metric}/{indices}", this);

    this.settingsFilter = settingsFilter;
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
public RestClusterGetSettingsAction(Settings settings, RestController controller, ClusterSettings clusterSettings,
        SettingsFilter settingsFilter) {
    super(settings);
    this.clusterSettings = clusterSettings;
    controller.registerHandler(RestRequest.Method.GET, "/_cluster/settings", this);
    this.settingsFilter = settingsFilter;
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Inject
public TransportGetSettingsAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                  ThreadPool threadPool, SettingsFilter settingsFilter, ActionFilters actionFilters,
                                  IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, GetSettingsAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, GetSettingsRequest::new);
    this.settingsFilter = settingsFilter;
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Override
public List<RestHandler> getRestHandlers(Settings settings,
                                         RestController restController,
                                         ClusterSettings clusterSettings,
                                         IndexScopedSettings indexScopedSettings,
                                         SettingsFilter settingsFilter,
                                         IndexNameExpressionResolver indexNameExpressionResolver,
                                         Supplier<DiscoveryNodes> nodesInCluster) {

    logger.debug("Registering REST handlers");

    handlers.forEach((key, value) -> restController.registerHandler(GET, key, value));
    return new ArrayList<>(handlers.values());
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Override
public List<RestHandler> getRestHandlers(Settings settings,
                                         RestController restController, ClusterSettings clusterSettings,
                                         IndexScopedSettings indexScopedSettings,
                                         SettingsFilter settingsFilter,
                                         IndexNameExpressionResolver indexNameExpressionResolver,
                                         Supplier<DiscoveryNodes> nodesInCluster) {
    return Arrays.asList(new ReportGenerateRestAction(settings, restController));
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Override
public List<RestHandler> getRestHandlers(final Settings settings, final RestController restController,
        final ClusterSettings clusterSettings, final IndexScopedSettings indexScopedSettings, final SettingsFilter settingsFilter,
        final IndexNameExpressionResolver indexNameExpressionResolver, final Supplier<DiscoveryNodes> nodesInCluster) {
    return Arrays.asList(new RestIndexingProxyProcessAction(settings, restController, pluginComponent),
            new RestIndexingProxyRequestAction(settings, restController, pluginComponent));
}
 

import org.elasticsearch.common.settings.SettingsFilter; //导入依赖的package包/类
@Inject
public RestGetRepositoriesAction(Settings settings, RestController controller, Client client, SettingsFilter settingsFilter) {
    super(settings, controller, client);
    controller.registerHandler(GET, "/_snapshot", this);
    controller.registerHandler(GET, "/_snapshot/{repository}", this);
    this.settingsFilter = settingsFilter;
}