Java 类org.elasticsearch.common.settings.IndexScopedSettings 实例源码

/**
 * Updates the settings and index metadata and notifies all registered settings consumers with the new settings iff at least one setting has changed.
 *
 * @return <code>true</code> iff any setting has been updated otherwise <code>false</code>.
 */
public synchronized boolean updateIndexMetaData(IndexMetaData indexMetaData) {
    final Settings newSettings = indexMetaData.getSettings();
    if (version.equals(Version.indexCreated(newSettings)) == false) {
        throw new IllegalArgumentException("version mismatch on settings update expected: " + version + " but was: " + Version.indexCreated(newSettings));
    }
    final String newUUID = newSettings.get(IndexMetaData.SETTING_INDEX_UUID, IndexMetaData.INDEX_UUID_NA_VALUE);
    if (newUUID.equals(getUUID()) == false) {
        throw new IllegalArgumentException("uuid mismatch on settings update expected: " + getUUID() + " but was: " + newUUID);
    }
    this.indexMetaData = indexMetaData;
    final Settings existingSettings = this.settings;
    if (existingSettings.filter(IndexScopedSettings.INDEX_SETTINGS_KEY_PREDICATE).getAsMap().equals(newSettings.filter(IndexScopedSettings.INDEX_SETTINGS_KEY_PREDICATE).getAsMap())) {
        // nothing to update, same settings
        return false;
    }
    scopedSettings.applySettings(newSettings);
    this.settings = Settings.builder().put(nodeSettings).put(newSettings).build();
    return true;
}

@Inject
public MetaDataCreateIndexService(Settings settings, ClusterService clusterService,
                                  IndicesService indicesService, AllocationService allocationService,
                                  AliasValidator aliasValidator, Environment env,
                                  IndexScopedSettings indexScopedSettings, ThreadPool threadPool,
                                  NamedXContentRegistry xContentRegistry) {
    super(settings);
    this.clusterService = clusterService;
    this.indicesService = indicesService;
    this.allocationService = allocationService;
    this.aliasValidator = aliasValidator;
    this.env = env;
    this.indexScopedSettings = indexScopedSettings;
    this.activeShardsObserver = new ActiveShardsObserver(settings, clusterService, threadPool);
    this.threadPool = threadPool;
    this.xContentRegistry = xContentRegistry;
}

public void testArchiveBrokenIndexSettings() {
    MetaDataIndexUpgradeService service = new MetaDataIndexUpgradeService(Settings.EMPTY, xContentRegistry(),
            new MapperRegistry(Collections.emptyMap(), Collections.emptyMap()), IndexScopedSettings.DEFAULT_SCOPED_SETTINGS);
    IndexMetaData src = newIndexMeta("foo", Settings.EMPTY);
    IndexMetaData indexMetaData = service.archiveBrokenIndexSettings(src);
    assertSame(indexMetaData, src);

    src = newIndexMeta("foo", Settings.builder().put("index.refresh_interval", "-200").build());
    indexMetaData = service.archiveBrokenIndexSettings(src);
    assertNotSame(indexMetaData, src);
    assertEquals("-200", indexMetaData.getSettings().get("archived.index.refresh_interval"));

    src = newIndexMeta("foo", Settings.builder().put("index.codec", "best_compression1").build());
    indexMetaData = service.archiveBrokenIndexSettings(src);
    assertNotSame(indexMetaData, src);
    assertEquals("best_compression1", indexMetaData.getSettings().get("archived.index.codec"));

    src = newIndexMeta("foo", Settings.builder().put("index.refresh.interval", "-1").build());
    indexMetaData = service.archiveBrokenIndexSettings(src);
    assertNotSame(indexMetaData, src);
    assertEquals("-1", indexMetaData.getSettings().get("archived.index.refresh.interval"));

    src = newIndexMeta("foo", indexMetaData.getSettings()); // double archive?
    indexMetaData = service.archiveBrokenIndexSettings(src);
    assertSame(indexMetaData, src);
}

public void testFailUpgrade() {
    MetaDataIndexUpgradeService service = new MetaDataIndexUpgradeService(Settings.EMPTY, xContentRegistry(),
            new MapperRegistry(Collections.emptyMap(), Collections.emptyMap()), IndexScopedSettings.DEFAULT_SCOPED_SETTINGS);
    final IndexMetaData metaData = newIndexMeta("foo", Settings.builder()
        .put(IndexMetaData.SETTING_VERSION_UPGRADED, Version.V_5_0_0_beta1)
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.fromString("2.4.0"))
        .put(IndexMetaData.SETTING_VERSION_MINIMUM_COMPATIBLE,
        Version.CURRENT.luceneVersion.toString()).build());
    String message = expectThrows(IllegalStateException.class, () -> service.upgradeIndexMetaData(metaData,
        Version.CURRENT.minimumIndexCompatibilityVersion())).getMessage();
    assertEquals(message, "The index [[foo/BOOM]] was created with version [2.4.0] but the minimum compatible version is [5.0.0]." +
        " It should be re-indexed in Elasticsearch 5.x before upgrading to " + Version.CURRENT.toString() + ".");

    IndexMetaData goodMeta = newIndexMeta("foo", Settings.builder()
        .put(IndexMetaData.SETTING_VERSION_UPGRADED, Version.V_5_0_0_beta1)
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.fromString("5.1.0"))
        .put(IndexMetaData.SETTING_VERSION_MINIMUM_COMPATIBLE,
            Version.CURRENT.luceneVersion.toString()).build());
    service.upgradeIndexMetaData(goodMeta, Version.V_5_0_0.minimumIndexCompatibilityVersion());
}

private static List<Throwable> putTemplate(NamedXContentRegistry xContentRegistry, PutRequest request) {
    MetaDataCreateIndexService createIndexService = new MetaDataCreateIndexService(
            Settings.EMPTY,
            null,
            null,
            null,
            null,
            null, null, null, xContentRegistry);
    MetaDataIndexTemplateService service = new MetaDataIndexTemplateService(Settings.EMPTY, null, createIndexService,
            new AliasValidator(Settings.EMPTY), null,
            new IndexScopedSettings(Settings.EMPTY, IndexScopedSettings.BUILT_IN_INDEX_SETTINGS), xContentRegistry);

    final List<Throwable> throwables = new ArrayList<>();
    service.putTemplate(request, new MetaDataIndexTemplateService.PutListener() {
        @Override
        public void onResponse(MetaDataIndexTemplateService.PutResponse response) {

        }

        @Override
        public void onFailure(Exception e) {
            throwables.add(e);
        }
    });
    return throwables;
}

@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));
}

@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));
}

@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));
}

public static IndexSettings newIndexSettings(Index index, Settings indexSetting, Settings nodeSettings, Setting<?>... setting) {
    Settings build = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
        .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)
        .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 1)
        .put(indexSetting)
        .build();
    IndexMetaData metaData = IndexMetaData.builder(index.getName()).settings(build).build();
    Set<Setting<?>> settingSet = new HashSet<>(IndexScopedSettings.BUILT_IN_INDEX_SETTINGS);
    if (setting.length > 0) {
        settingSet.addAll(Arrays.asList(setting));
    }
    return new IndexSettings(metaData, nodeSettings, new IndexScopedSettings(Settings.EMPTY, settingSet));
}

public static IndexSettings newIndexSettings(Index index, Settings settings, IndexScopedSettings indexScopedSettings) {
    Settings build = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)
            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 1)
            .put(settings)
            .build();
    IndexMetaData metaData = IndexMetaData.builder(index.getName()).settings(build).build();
    return new IndexSettings(metaData, Settings.EMPTY, indexScopedSettings);
}

public static IndexSettings newIndexSettings(final IndexMetaData indexMetaData, Setting<?>... setting) {
    Set<Setting<?>> settingSet = new HashSet<>(IndexScopedSettings.BUILT_IN_INDEX_SETTINGS);
    if (setting.length > 0) {
        settingSet.addAll(Arrays.asList(setting));
    }
    return new IndexSettings(indexMetaData, Settings.EMPTY, new IndexScopedSettings(Settings.EMPTY, settingSet));
}

public IndicesService(Settings settings, PluginsService pluginsService, NodeEnvironment nodeEnv, NamedXContentRegistry xContentRegistry,
                      ClusterSettings clusterSettings, AnalysisRegistry analysisRegistry,
                      IndexNameExpressionResolver indexNameExpressionResolver,
                      MapperRegistry mapperRegistry, NamedWriteableRegistry namedWriteableRegistry,
                      ThreadPool threadPool, IndexScopedSettings indexScopedSettings, CircuitBreakerService circuitBreakerService,
                      BigArrays bigArrays, ScriptService scriptService, ClusterService clusterService, Client client,
                      MetaStateService metaStateService) {
    super(settings);
    this.threadPool = threadPool;
    this.pluginsService = pluginsService;
    this.nodeEnv = nodeEnv;
    this.xContentRegistry = xContentRegistry;
    this.shardsClosedTimeout = settings.getAsTime(INDICES_SHARDS_CLOSED_TIMEOUT, new TimeValue(1, TimeUnit.DAYS));
    this.analysisRegistry = analysisRegistry;
    this.indexNameExpressionResolver = indexNameExpressionResolver;
    this.indicesRequestCache = new IndicesRequestCache(settings);
    this.indicesQueryCache = new IndicesQueryCache(settings);
    this.mapperRegistry = mapperRegistry;
    this.namedWriteableRegistry = namedWriteableRegistry;
    indexingMemoryController = new IndexingMemoryController(settings, threadPool,
                                                            // ensure we pull an iter with new shards - flatten makes a copy
                                                            () -> Iterables.flatten(this).iterator());
    this.indexScopeSetting = indexScopedSettings;
    this.circuitBreakerService = circuitBreakerService;
    this.bigArrays = bigArrays;
    this.scriptService = scriptService;
    this.clusterService = clusterService;
    this.client = client;
    this.indicesFieldDataCache = new IndicesFieldDataCache(settings, new IndexFieldDataCache.Listener() {
        @Override
        public void onRemoval(ShardId shardId, String fieldName, boolean wasEvicted, long sizeInBytes) {
            assert sizeInBytes >= 0 : "When reducing circuit breaker, it should be adjusted with a number higher or equal to 0 and not [" + sizeInBytes + "]";
            circuitBreakerService.getBreaker(CircuitBreaker.FIELDDATA).addWithoutBreaking(-sizeInBytes);
        }
    });
    this.cleanInterval = INDICES_CACHE_CLEAN_INTERVAL_SETTING.get(settings);
    this.cacheCleaner = new CacheCleaner(indicesFieldDataCache, indicesRequestCache,  logger, threadPool, this.cleanInterval);
    this.metaStateService = metaStateService;
}

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;
}

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;
}

@Inject
public MetaDataUpdateSettingsService(Settings settings, ClusterService clusterService, AllocationService allocationService,
                                     IndexScopedSettings indexScopedSettings, IndicesService indicesService, ThreadPool threadPool) {
    super(settings);
    this.clusterService = clusterService;
    this.threadPool = threadPool;
    this.clusterService.addListener(this);
    this.allocationService = allocationService;
    this.indexScopedSettings = indexScopedSettings;
    this.indicesService = indicesService;
}

@Inject
public MetaDataIndexTemplateService(Settings settings, ClusterService clusterService,
                                    MetaDataCreateIndexService metaDataCreateIndexService,
                                    AliasValidator aliasValidator, IndicesService indicesService,
                                    IndexScopedSettings indexScopedSettings, NamedXContentRegistry xContentRegistry) {
    super(settings);
    this.clusterService = clusterService;
    this.aliasValidator = aliasValidator;
    this.indicesService = indicesService;
    this.metaDataCreateIndexService = metaDataCreateIndexService;
    this.indexScopedSettings = indexScopedSettings;
    this.xContentRegistry = xContentRegistry;
}

@Inject
public MetaDataIndexUpgradeService(Settings settings, NamedXContentRegistry xContentRegistry, MapperRegistry mapperRegistry,
        IndexScopedSettings indexScopedSettings) {
    super(settings);
    this.xContentRegistry = xContentRegistry;
    this.mapperRegistry = mapperRegistry;
    this.indexScopedSettings = indexScopedSettings;
}

@Inject
public TransportPutIndexTemplateAction(Settings settings, TransportService transportService, ClusterService clusterService,
                                       ThreadPool threadPool, MetaDataIndexTemplateService indexTemplateService,
                                       ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver, IndexScopedSettings indexScopedSettings) {
    super(settings, PutIndexTemplateAction.NAME, transportService, clusterService, threadPool, actionFilters, indexNameExpressionResolver, PutIndexTemplateRequest::new);
    this.indexTemplateService = indexTemplateService;
    this.indexScopedSettings = indexScopedSettings;
}

public IndexSettings newIndexSettings(IndexMetaData metaData, Settings nodeSettings, Setting<?>... settings) {
    Set<Setting<?>> settingSet = new HashSet<>(IndexScopedSettings.BUILT_IN_INDEX_SETTINGS);
    if (settings.length > 0) {
        settingSet.addAll(Arrays.asList(settings));
    }
    return new IndexSettings(metaData, nodeSettings, new IndexScopedSettings(Settings.EMPTY, settingSet));
}

public void testInvalidIPFilter() {
    String ipKey = randomFrom("_ip", "_host_ip", "_publish_ip");
    Setting<Settings> filterSetting = randomFrom(IndexMetaData.INDEX_ROUTING_REQUIRE_GROUP_SETTING,
        IndexMetaData.INDEX_ROUTING_INCLUDE_GROUP_SETTING, IndexMetaData.INDEX_ROUTING_EXCLUDE_GROUP_SETTING);
    IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> {
        IndexScopedSettings indexScopedSettings = new IndexScopedSettings(Settings.EMPTY, IndexScopedSettings.BUILT_IN_INDEX_SETTINGS);
        indexScopedSettings.updateDynamicSettings(Settings.builder().put(filterSetting.getKey() + ipKey, "192..168.1.1").build(),
            Settings.builder().put(Settings.EMPTY), Settings.builder(), "test ip validation");
    });
    assertEquals("invalid IP address [192..168.1.1] for [" + ipKey + "]", e.getMessage());
}

public void testUpgrade() {
    MetaDataIndexUpgradeService service = new MetaDataIndexUpgradeService(Settings.EMPTY, xContentRegistry(),
            new MapperRegistry(Collections.emptyMap(), Collections.emptyMap()), IndexScopedSettings.DEFAULT_SCOPED_SETTINGS);
    IndexMetaData src = newIndexMeta("foo", Settings.builder().put("index.refresh_interval", "-200").build());
    assertFalse(service.isUpgraded(src));
    src = service.upgradeIndexMetaData(src, Version.CURRENT.minimumIndexCompatibilityVersion());
    assertTrue(service.isUpgraded(src));
    assertEquals("-200", src.getSettings().get("archived.index.refresh_interval"));
    assertNull(src.getSettings().get("index.refresh_interval"));
    assertSame(src, service.upgradeIndexMetaData(src, Version.CURRENT.minimumIndexCompatibilityVersion())); // no double upgrade
}

public void testIsUpgraded() {
    MetaDataIndexUpgradeService service = new MetaDataIndexUpgradeService(Settings.EMPTY, xContentRegistry(),
            new MapperRegistry(Collections.emptyMap(), Collections.emptyMap()), IndexScopedSettings.DEFAULT_SCOPED_SETTINGS);
    IndexMetaData src = newIndexMeta("foo", Settings.builder().put("index.refresh_interval", "-200").build());
    assertFalse(service.isUpgraded(src));
    Version version = VersionUtils.randomVersionBetween(random(), VersionUtils.getFirstVersion(), VersionUtils.getPreviousVersion());
    src = newIndexMeta("foo", Settings.builder().put(IndexMetaData.SETTING_VERSION_UPGRADED, version).build());
    assertFalse(service.isUpgraded(src));
    src = newIndexMeta("foo", Settings.builder().put(IndexMetaData.SETTING_VERSION_UPGRADED, Version.CURRENT).build());
    assertTrue(service.isUpgraded(src));
}

private List<Throwable> putTemplateDetail(PutRequest request) throws Exception {
    IndicesService indicesService = getInstanceFromNode(IndicesService.class);
    ClusterService clusterService = getInstanceFromNode(ClusterService.class);
    MetaDataCreateIndexService createIndexService = new MetaDataCreateIndexService(
        Settings.EMPTY,
        clusterService,
        indicesService,
        null,
        null,
        null,
        null,
        null,
        xContentRegistry());
    MetaDataIndexTemplateService service = new MetaDataIndexTemplateService(
            Settings.EMPTY, clusterService, createIndexService, new AliasValidator(Settings.EMPTY), indicesService,
            new IndexScopedSettings(Settings.EMPTY, IndexScopedSettings.BUILT_IN_INDEX_SETTINGS), xContentRegistry());

    final List<Throwable> throwables = new ArrayList<>();
    final CountDownLatch latch = new CountDownLatch(1);
    service.putTemplate(request, new MetaDataIndexTemplateService.PutListener() {
        @Override
        public void onResponse(MetaDataIndexTemplateService.PutResponse response) {
            latch.countDown();
        }

        @Override
        public void onFailure(Exception e) {
            throwables.add(e);
            latch.countDown();
        }
    });
    latch.await();
    return throwables;
}

@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());
}

@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));
}

@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));
}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    log(1, "---> getRestHandlers");

    return Arrays.asList(new RestConsoleAction(settings, restController, clusterSettings, settingsFilter));

}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController,
                                         ClusterSettings clusterSettings, IndexScopedSettings indexScopedSettings,
                                         SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
                                         Supplier<DiscoveryNodes> nodesInCluster) {
    List<RestHandler> list = new ArrayList<>();
    RestSimpleFeatureStore.register(list, settings, restController);
    list.add(new RestFeatureStoreCaches(settings, restController));
    list.add(new RestCreateModelFromSet(settings, restController));
    list.add(new RestAddFeatureToSet(settings, restController));
    return unmodifiableList(list);
}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    log(1, "---> getRestHandlers");

    return Arrays.asList(new RestSpToolsAction(settings, restController), new RestConsoleAction(settings, restController, clusterSettings, settingsFilter));

}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter,
        IndexNameExpressionResolver indexNameExpressionResolver, Supplier<DiscoveryNodes> nodesInCluster) {

    final List<RestHandler> handlers = new ArrayList<RestHandler>(1);

    if (!client && !tribeNodeClient && !disabled) {

        handlers.addAll(super.getRestHandlers(settings, restController, clusterSettings, indexScopedSettings, settingsFilter, indexNameExpressionResolver, nodesInCluster));

        handlers.add(new SearchGuardInfoAction(settings, restController, Objects.requireNonNull(evaluator), Objects.requireNonNull(threadPool)));
        handlers.add(new KibanaInfoAction(settings, restController, Objects.requireNonNull(evaluator), Objects.requireNonNull(threadPool)));
        handlers.add(new SearchGuardLicenseAction(settings, restController));
        handlers.add(new SearchGuardHealthAction(settings, restController, Objects.requireNonNull(backendRegistry)));

        Collection<RestHandler> apiHandler = ReflectionHelper
                .instantiateMngtRestApiHandler(settings, configPath, restController, localClient, adminDns, cr, cs, Objects.requireNonNull(principalExtractor),  evaluator, threadPool, Objects.requireNonNull(auditLog));
        handlers.addAll(apiHandler);
        log.debug("Added {} management rest handler(s)", apiHandler.size());
    }


    final Set<ModuleInfo> sgModules = ReflectionHelper.getModulesLoaded();

    log.info("{} Search Guard modules loaded so far: {}", sgModules.size(), sgModules);

    return handlers;
}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter,
        IndexNameExpressionResolver indexNameExpressionResolver, Supplier<DiscoveryNodes> nodesInCluster) {

    final List<RestHandler> handlers = new ArrayList<RestHandler>(1);

    if (!client) {
        handlers.add(new SearchGuardSSLInfoAction(settings, configPath, restController, sgks, Objects.requireNonNull(principalExtractor)));
    }

    return handlers;
}

@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) {
    final ConfigSyncService service = pluginComponent.getConfigSyncService();
    return Arrays.asList(//
            new RestConfigSyncFileAction(settings, restController, service), //
            new RestConfigSyncResetAction(settings, restController, service), //
            new RestConfigSyncFlushAction(settings, restController, service), //
            new RestConfigSyncWaitAction(settings, restController, service));
}

@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 RestSearchScriptTemplateAction(settings, restController), //
            new RestMultiSearchScriptTemplateAction(settings, restController), //
            new RestGetSearchScriptTemplateAction(settings, restController), //
            new RestPutSearchScriptTemplateAction(settings, restController), //
            new RestDeleteSearchScriptTemplateAction(settings, restController), //
            new RestRenderSearchScriptTemplateAction(settings, restController));
}

@Override
public List<RestHandler> getRestHandlers(Settings settings,
                                         RestController restController,
                                         ClusterSettings clusterSettings,
                                         IndexScopedSettings indexScopedSettings,
                                         SettingsFilter settingsFilter,
                                         IndexNameExpressionResolver indexNameExpressionResolver,
                                         Supplier<DiscoveryNodes> nodesInCluster) {
    List<RestHandler> extra = new ArrayList<>();
    extra.add(new RestISBNFormatterAction(settings, restController));
    extra.add(new RestLangdetectAction(settings, restController));
    return extra;
}

@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 RestDataAction(settings, restController));
}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController,
  ClusterSettings clusterSettings, IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter,
  IndexNameExpressionResolver indexNameExpressionResolver, Supplier<DiscoveryNodes> nodesInCluster) {
return Arrays.asList(
    new ClusteringAction.RestClusteringAction(settings, restController),
    new ListAlgorithmsAction.RestListAlgorithmsAction(settings, restController));
}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    return Collections.singletonList(new TestDeprecationHeaderRestAction(settings, restController));
}

@Override
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
        Supplier<DiscoveryNodes> nodesInCluster) {
    return singletonList(new TestResponseHeaderRestAction(settings, restController));
}

/**
 * Creates a new {@link IndexSettings} instance. The given node settings will be merged with the settings in the metadata
 * while index level settings will overwrite node settings.
 *
 * @param indexMetaData the index metadata this settings object is associated with
 * @param nodeSettings the nodes settings this index is allocated on.
 */
public IndexSettings(final IndexMetaData indexMetaData, final Settings nodeSettings, IndexScopedSettings indexScopedSettings) {
    scopedSettings = indexScopedSettings.copy(nodeSettings, indexMetaData);
    this.nodeSettings = nodeSettings;
    this.settings = Settings.builder().put(nodeSettings).put(indexMetaData.getSettings()).build();
    this.index = indexMetaData.getIndex();
    version = Version.indexCreated(settings);
    logger = Loggers.getLogger(getClass(), settings, index);
    nodeName = Node.NODE_NAME_SETTING.get(settings);
    this.indexMetaData = indexMetaData;
    numberOfShards = settings.getAsInt(IndexMetaData.SETTING_NUMBER_OF_SHARDS, null);
    isShadowReplicaIndex = indexMetaData.isIndexUsingShadowReplicas(settings);

    this.defaultField = DEFAULT_FIELD_SETTING.get(settings);
    this.queryStringLenient = QUERY_STRING_LENIENT_SETTING.get(settings);
    this.queryStringAnalyzeWildcard = QUERY_STRING_ANALYZE_WILDCARD.get(nodeSettings);
    this.queryStringAllowLeadingWildcard = QUERY_STRING_ALLOW_LEADING_WILDCARD.get(nodeSettings);
    this.defaultAllowUnmappedFields = scopedSettings.get(ALLOW_UNMAPPED);
    this.durability = scopedSettings.get(INDEX_TRANSLOG_DURABILITY_SETTING);
    syncInterval = INDEX_TRANSLOG_SYNC_INTERVAL_SETTING.get(settings);
    refreshInterval = scopedSettings.get(INDEX_REFRESH_INTERVAL_SETTING);
    globalCheckpointInterval = scopedSettings.get(INDEX_SEQ_NO_CHECKPOINT_SYNC_INTERVAL);
    flushThresholdSize = scopedSettings.get(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING);
    mergeSchedulerConfig = new MergeSchedulerConfig(this);
    gcDeletesInMillis = scopedSettings.get(INDEX_GC_DELETES_SETTING).getMillis();
    warmerEnabled = scopedSettings.get(INDEX_WARMER_ENABLED_SETTING);
    maxResultWindow = scopedSettings.get(MAX_RESULT_WINDOW_SETTING);
    maxAdjacencyMatrixFilters = scopedSettings.get(MAX_ADJACENCY_MATRIX_FILTERS_SETTING);
    maxRescoreWindow = scopedSettings.get(MAX_RESCORE_WINDOW_SETTING);
    TTLPurgeDisabled = scopedSettings.get(INDEX_TTL_DISABLE_PURGE_SETTING);
    maxRefreshListeners = scopedSettings.get(MAX_REFRESH_LISTENERS_PER_SHARD);
    maxSlicesPerScroll = scopedSettings.get(MAX_SLICES_PER_SCROLL);
    this.mergePolicyConfig = new MergePolicyConfig(logger, this);

    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_COMPOUND_FORMAT_SETTING, mergePolicyConfig::setNoCFSRatio);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_EXPUNGE_DELETES_ALLOWED_SETTING, mergePolicyConfig::setExpungeDeletesAllowed);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_FLOOR_SEGMENT_SETTING, mergePolicyConfig::setFloorSegmentSetting);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_MAX_MERGE_AT_ONCE_SETTING, mergePolicyConfig::setMaxMergesAtOnce);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_MAX_MERGE_AT_ONCE_EXPLICIT_SETTING, mergePolicyConfig::setMaxMergesAtOnceExplicit);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_MAX_MERGED_SEGMENT_SETTING, mergePolicyConfig::setMaxMergedSegment);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_SEGMENTS_PER_TIER_SETTING, mergePolicyConfig::setSegmentsPerTier);
    scopedSettings.addSettingsUpdateConsumer(MergePolicyConfig.INDEX_MERGE_POLICY_RECLAIM_DELETES_WEIGHT_SETTING, mergePolicyConfig::setReclaimDeletesWeight);

    scopedSettings.addSettingsUpdateConsumer(MergeSchedulerConfig.MAX_THREAD_COUNT_SETTING, MergeSchedulerConfig.MAX_MERGE_COUNT_SETTING,
        mergeSchedulerConfig::setMaxThreadAndMergeCount);
    scopedSettings.addSettingsUpdateConsumer(MergeSchedulerConfig.AUTO_THROTTLE_SETTING, mergeSchedulerConfig::setAutoThrottle);
    scopedSettings.addSettingsUpdateConsumer(INDEX_TRANSLOG_DURABILITY_SETTING, this::setTranslogDurability);
    scopedSettings.addSettingsUpdateConsumer(INDEX_TTL_DISABLE_PURGE_SETTING, this::setTTLPurgeDisabled);
    scopedSettings.addSettingsUpdateConsumer(MAX_RESULT_WINDOW_SETTING, this::setMaxResultWindow);
    scopedSettings.addSettingsUpdateConsumer(MAX_ADJACENCY_MATRIX_FILTERS_SETTING, this::setMaxAdjacencyMatrixFilters);
    scopedSettings.addSettingsUpdateConsumer(MAX_RESCORE_WINDOW_SETTING, this::setMaxRescoreWindow);
    scopedSettings.addSettingsUpdateConsumer(INDEX_WARMER_ENABLED_SETTING, this::setEnableWarmer);
    scopedSettings.addSettingsUpdateConsumer(INDEX_GC_DELETES_SETTING, this::setGCDeletes);
    scopedSettings.addSettingsUpdateConsumer(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING, this::setTranslogFlushThresholdSize);
    scopedSettings.addSettingsUpdateConsumer(INDEX_REFRESH_INTERVAL_SETTING, this::setRefreshInterval);
    scopedSettings.addSettingsUpdateConsumer(MAX_REFRESH_LISTENERS_PER_SHARD, this::setMaxRefreshListeners);
    scopedSettings.addSettingsUpdateConsumer(MAX_SLICES_PER_SCROLL, this::setMaxSlicesPerScroll);
}

/**
 * Rest handlers added by this plugin.
 */
default List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
        IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter,
        IndexNameExpressionResolver indexNameExpressionResolver, Supplier<DiscoveryNodes> nodesInCluster) {
    return Collections.emptyList();
}