Optimize index template registry

Author: nielsbauman

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/template/IndexTemplateRegistry.java

@@ -246,13 +246,39 @@ public void clusterChanged(ClusterChangedEvent event) {
         if (event.localNodeMaster() == false && localNodeVersionAfterMaster == false) {
             return;
         }
+        boolean settingsChanged = settingsChanged(event);
         for (ProjectMetadata project : event.state().metadata().projects().values()) {
+            final ProjectMetadata previousProject = event.previousState().metadata().projects().get(project.id());
+            if (settingsChanged == false && projectChanged(previousProject, project) == false) {
+                continue;
+            }
             addIngestPipelinesIfMissing(project);
             addTemplatesIfMissing(project);
             addIndexLifecyclePoliciesIfMissing(project);
         }
     }
 
+    private boolean projectChanged(ProjectMetadata previousProject, ProjectMetadata newProject) {
+        if (previousProject == null) {
+            return true;
+        }
+        return newProject.templates().isEmpty()
+            || newProject.templates() != previousProject.templates()
+            || newProject.templatesV2().isEmpty()
+            || newProject.templatesV2() != previousProject.templatesV2()
+            || newProject.componentTemplates().isEmpty()
+            || newProject.componentTemplates() != previousProject.componentTemplates()
+            || newProject.custom(IndexLifecycleMetadata.TYPE) == null
+            || newProject.custom(IndexLifecycleMetadata.TYPE) != previousProject.custom(IndexLifecycleMetadata.TYPE)
+            || newProject.custom(IngestMetadata.TYPE) == null
+            || newProject.custom(IngestMetadata.TYPE) != previousProject.custom(IngestMetadata.TYPE);
+    }
+
+    private boolean settingsChanged(ClusterChangedEvent event) {
+        return event.state().metadata().persistentSettings() != event.previousState().metadata().persistentSettings()
+            || event.state().metadata().transientSettings() != event.previousState().metadata().transientSettings();
+    }
+
     /**
      * A method that can be overridden to add additional conditions to be satisfied
      * before installing the template registry components.
@@ -325,18 +351,19 @@ private void addComponentTemplatesIfMissing(ProjectMetadata project) {
         final Map<String, ComponentTemplate> indexTemplates = getComponentTemplateConfigs();
         for (Map.Entry<String, ComponentTemplate> newTemplate : indexTemplates.entrySet()) {
             final String templateName = newTemplate.getKey();
+            if (templateDependenciesSatisfied(project, newTemplate.getValue()) == false) {
+                logger.trace(
+                    "not adding index template [{}] for [{}] because its required dependencies do not exist",
+                    templateName,
+                    getOrigin()
+                );
+                continue;
+            }
             final AtomicBoolean creationCheck = templateCreationsInProgress.computeIfAbsent(project.id(), key -> new ConcurrentHashMap<>())
                 .computeIfAbsent(templateName, key -> new AtomicBoolean(false));
             if (creationCheck.compareAndSet(false, true)) {
                 ComponentTemplate currentTemplate = project.componentTemplates().get(templateName);
-                if (templateDependenciesSatisfied(project, newTemplate.getValue()) == false) {
-                    creationCheck.set(false);
-                    logger.trace(
-                        "not adding index template [{}] for [{}] because its required dependencies do not exist",
-                        templateName,
-                        getOrigin()
-                    );
-                } else if (Objects.isNull(currentTemplate)) {
+                if (Objects.isNull(currentTemplate)) {
                     logger.debug("adding component template [{}] for [{}], because it doesn't exist", templateName, getOrigin());
                     putComponentTemplate(project.id(), templateName, newTemplate.getValue(), creationCheck);
                 } else if (Objects.isNull(currentTemplate.version()) || newTemplate.getValue().version() > currentTemplate.version()) {
@@ -399,22 +426,23 @@ private void addComposableTemplatesIfMissing(ProjectMetadata project) {
         final Map<String, ComposableIndexTemplate> indexTemplates = getComposableTemplateConfigs();
         for (Map.Entry<String, ComposableIndexTemplate> newTemplate : indexTemplates.entrySet()) {
             final String templateName = newTemplate.getKey();
+            boolean componentTemplatesAvailable = componentTemplatesInstalled(project, newTemplate.getValue());
+            if (componentTemplatesAvailable == false) {
+                if (logger.isTraceEnabled()) {
+                    logger.trace(
+                        "not adding composable template [{}] for [{}] because its required component templates do not exist or do not "
+                            + "have the right version",
+                        templateName,
+                        getOrigin()
+                    );
+                }
+                continue;
+            }
             final AtomicBoolean creationCheck = templateCreationsInProgress.computeIfAbsent(project.id(), key -> new ConcurrentHashMap<>())
                 .computeIfAbsent(templateName, key -> new AtomicBoolean(false));
             if (creationCheck.compareAndSet(false, true)) {
                 ComposableIndexTemplate currentTemplate = project.templatesV2().get(templateName);
-                boolean componentTemplatesAvailable = componentTemplatesInstalled(project, newTemplate.getValue());
-                if (componentTemplatesAvailable == false) {
-                    creationCheck.set(false);
-                    if (logger.isTraceEnabled()) {
-                        logger.trace(
-                            "not adding composable template [{}] for [{}] because its required component templates do not exist or do not "
-                                + "have the right version",
-                            templateName,
-                            getOrigin()
-                        );
-                    }
-                } else if (Objects.isNull(currentTemplate)) {
+                if (Objects.isNull(currentTemplate)) {
                     logger.debug("adding composable template [{}] for [{}], because it doesn't exist", templateName, getOrigin());
                     putComposableTemplate(project, templateName, newTemplate.getValue(), creationCheck);
                 } else if (Objects.isNull(currentTemplate.version()) || newTemplate.getValue().version() > currentTemplate.version()) {
@@ -679,19 +707,20 @@ protected static Map<String, ComposableIndexTemplate> parseComposableTemplates(I
 
     private void addIngestPipelinesIfMissing(ProjectMetadata project) {
         for (IngestPipelineConfig requiredPipeline : getIngestPipelines()) {
+            List<String> pipelineDependencies = requiredPipeline.getPipelineDependencies();
+            if (pipelineDependencies != null && pipelineDependenciesExist(project, pipelineDependencies) == false) {
+                logger.trace(
+                    "not adding ingest pipeline [{}] for [{}] because its dependencies do not exist",
+                    requiredPipeline.getId(),
+                    getOrigin()
+                );
+                continue;
+            }
             final AtomicBoolean creationCheck = pipelineCreationsInProgress.computeIfAbsent(project.id(), key -> new ConcurrentHashMap<>())
                 .computeIfAbsent(requiredPipeline.getId(), key -> new AtomicBoolean(false));
 
             if (creationCheck.compareAndSet(false, true)) {
-                List<String> pipelineDependencies = requiredPipeline.getPipelineDependencies();
-                if (pipelineDependencies != null && pipelineDependenciesExist(project, pipelineDependencies) == false) {
-                    creationCheck.set(false);
-                    logger.trace(
-                        "not adding ingest pipeline [{}] for [{}] because its dependencies do not exist",
-                        requiredPipeline.getId(),
-                        getOrigin()
-                    );
-                } else {
+                {
                     PipelineConfiguration existingPipeline = findInstalledPipeline(project, requiredPipeline.getId());
                     if (existingPipeline != null) {
                         Integer existingPipelineVersion = existingPipeline.getVersion();