Remove tasks module to define tasks system index (#61540)

This commit removes the tasks module that only existed to define the
tasks result index, `.tasks`,  as a system index. The definition for
the tasks results system index descriptor is moved to the
`SystemIndices` class with a check that no other plugin or module
attempts to define an entry with the same source.

Additionally, this change also makes the pattern for the tasks result
index a wildcard pattern since we will need this when the index is
upgraded (reindex to new name and then alias that to .tasks).

Author: jaymode

modules/tasks/build.gradle

@@ -28,15 +28,18 @@
 import org.elasticsearch.common.collect.Tuple;
 import org.elasticsearch.common.regex.Regex;
 import org.elasticsearch.index.Index;
+import org.elasticsearch.tasks.TaskResultsService;
 
 import java.util.Collection;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
 import static java.util.stream.Collectors.toUnmodifiableList;
+import static org.elasticsearch.tasks.TaskResultsService.TASK_INDEX;
 
 /**
  * This class holds the {@link SystemIndexDescriptor} objects that represent system indices the
@@ -45,12 +48,17 @@
  */
 public class SystemIndices {
 
+    private static final Map<String, Collection<SystemIndexDescriptor>> SERVER_SYSTEM_INDEX_DESCRIPTORS = Map.of(
+        TaskResultsService.class.getName(), List.of(new SystemIndexDescriptor(TASK_INDEX + "*", "Task Result Index"))
+    );
+
     private final CharacterRunAutomaton runAutomaton;
     private final Collection<SystemIndexDescriptor> systemIndexDescriptors;
 
-    public SystemIndices(Map<String, Collection<SystemIndexDescriptor>> systemIndexDescriptorMap) {
-        checkForOverlappingPatterns(systemIndexDescriptorMap);
-        this.systemIndexDescriptors = systemIndexDescriptorMap.values()
+    public SystemIndices(Map<String, Collection<SystemIndexDescriptor>> pluginAndModulesDescriptors) {
+        final Map<String, Collection<SystemIndexDescriptor>> descriptorsMap = buildSystemIndexDescriptorMap(pluginAndModulesDescriptors);
+        checkForOverlappingPatterns(descriptorsMap);
+        this.systemIndexDescriptors = descriptorsMap.values()
             .stream()
             .flatMap(Collection::stream)
             .collect(Collectors.toUnmodifiableList());
@@ -63,7 +71,16 @@ public SystemIndices(Map<String, Collection<SystemIndexDescriptor>> systemIndexD
      * @return true if the {@link Index}'s name matches a pattern from a {@link SystemIndexDescriptor}
      */
     public boolean isSystemIndex(Index index) {
-        return runAutomaton.run(index.getName());
+        return isSystemIndex(index.getName());
+    }
+
+    /**
+     * Determines whether a given index is a system index by comparing its name to the collection of loaded {@link SystemIndexDescriptor}s
+     * @param indexName the index name to check against loaded {@link SystemIndexDescriptor}s
+     * @return true if the index name matches a pattern from a {@link SystemIndexDescriptor}
+     */
+    public boolean isSystemIndex(String indexName) {
+        return runAutomaton.run(indexName);
     }
 
     /**
@@ -126,10 +143,10 @@ static void checkForOverlappingPatterns(Map<String, Collection<SystemIndexDescri
                 .filter(d -> overlaps(descriptorToCheck.v2(), d.v2()))
                 .collect(Collectors.toUnmodifiableList());
             if (descriptorsMatchingThisPattern.isEmpty() == false) {
-                throw new IllegalStateException("a system index descriptor [" + descriptorToCheck.v2() + "] from plugin [" +
+                throw new IllegalStateException("a system index descriptor [" + descriptorToCheck.v2() + "] from [" +
                     descriptorToCheck.v1() + "] overlaps with other system index descriptors: [" +
                     descriptorsMatchingThisPattern.stream()
-                        .map(descriptor -> descriptor.v2() + " from plugin [" + descriptor.v1() + "]")
+                        .map(descriptor -> descriptor.v2() + " from [" + descriptor.v1() + "]")
                         .collect(Collectors.joining(", ")));
             }
         });
@@ -140,4 +157,19 @@ private static boolean overlaps(SystemIndexDescriptor a1, SystemIndexDescriptor
         Automaton a2Automaton = Regex.simpleMatchToAutomaton(a2.getIndexPattern());
         return Operations.isEmpty(Operations.intersection(a1Automaton, a2Automaton)) == false;
     }
+
+    private static Map<String, Collection<SystemIndexDescriptor>> buildSystemIndexDescriptorMap(
+        Map<String, Collection<SystemIndexDescriptor>> pluginAndModulesMap) {
+        final Map<String, Collection<SystemIndexDescriptor>> map =
+            new HashMap<>(pluginAndModulesMap.size() + SERVER_SYSTEM_INDEX_DESCRIPTORS.size());
+        map.putAll(pluginAndModulesMap);
+        // put the server items last since we expect less of them
+        SERVER_SYSTEM_INDEX_DESCRIPTORS.forEach((source, descriptors) -> {
+            if (map.putIfAbsent(source, descriptors) != null) {
+                throw new IllegalArgumentException("plugin or module attempted to define the same source [" + source +
+                    "] as a built-in system index");
+            }
+        });
+        return Map.copyOf(map);
+    }
 }

modules/tasks/src/main/java/org/elasticsearch/tasksplugin/TasksPlugin.java

@@ -19,13 +19,15 @@
 
 package org.elasticsearch.indices;
 
+import org.elasticsearch.tasks.TaskResultsService;
 import org.elasticsearch.test.ESTestCase;
 
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static org.elasticsearch.tasks.TaskResultsService.TASK_INDEX;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
@@ -50,8 +52,8 @@ public void testBasicOverlappingPatterns() {
         IllegalStateException exception = expectThrows(IllegalStateException.class,
             () -> SystemIndices.checkForOverlappingPatterns(descriptors));
         assertThat(exception.getMessage(), containsString("a system index descriptor [" + broadPattern +
-            "] from plugin [" + broadPatternSource + "] overlaps with other system index descriptors:"));
-        String fromPluginString = " from plugin [" + otherSource + "]";
+            "] from [" + broadPatternSource + "] overlaps with other system index descriptors:"));
+        String fromPluginString = " from [" + otherSource + "]";
         assertThat(exception.getMessage(), containsString(overlapping1.toString() + fromPluginString));
         assertThat(exception.getMessage(), containsString(overlapping2.toString() + fromPluginString));
         assertThat(exception.getMessage(), containsString(overlapping3.toString() + fromPluginString));
@@ -77,10 +79,25 @@ public void testComplexOverlappingPatterns() {
         IllegalStateException exception = expectThrows(IllegalStateException.class,
             () -> SystemIndices.checkForOverlappingPatterns(descriptors));
         assertThat(exception.getMessage(), containsString("a system index descriptor [" + pattern1 +
-            "] from plugin [" + source1 + "] overlaps with other system index descriptors:"));
-        assertThat(exception.getMessage(), containsString(pattern2.toString() + " from plugin [" + source2 + "]"));
+            "] from [" + source1 + "] overlaps with other system index descriptors:"));
+        assertThat(exception.getMessage(), containsString(pattern2.toString() + " from [" + source2 + "]"));
 
         IllegalStateException constructorException = expectThrows(IllegalStateException.class, () -> new SystemIndices(descriptors));
         assertThat(constructorException.getMessage(), equalTo(exception.getMessage()));
     }
+
+    public void testBuiltInSystemIndices() {
+        SystemIndices systemIndices = new SystemIndices(Map.of());
+        assertTrue(systemIndices.isSystemIndex(".tasks"));
+        assertTrue(systemIndices.isSystemIndex(".tasks1"));
+        assertTrue(systemIndices.isSystemIndex(".tasks-old"));
+    }
+
+    public void testPluginCannotOverrideBuiltInSystemIndex() {
+        Map<String, Collection<SystemIndexDescriptor>> pluginMap = Map.of(
+            TaskResultsService.class.getName(), List.of(new SystemIndexDescriptor(TASK_INDEX, "Task Result Index"))
+        );
+        IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> new SystemIndices(pluginMap));
+        assertThat(e.getMessage(), containsString("plugin or module attempted to define the same source"));
+    }
 }