Add deprecation info and warnings for an empty TIER_PREFERENCE

server/src/main/java/org/elasticsearch/cluster/metadata/MetadataCreateIndexService.java

@@ -814,16 +814,26 @@ static Settings aggregateIndexSettings(ClusterState currentState, CreateIndexClu
         indexSettingsBuilder.put(requestSettings.build());
 
         if (sourceMetadata == null) { // not for shrink/split/clone
+            String currentTierPreference = indexSettingsBuilder.get(DataTier.TIER_PREFERENCE);
+            List<String> preferredTiers = DataTier.parseTierList(currentTierPreference);
             if (enforceDefaultTierPreference) {
                 // regardless of any previous logic, we're going to force there
                 // to be an appropriate non-empty value for the tier preference
-                String currentTierPreference = indexSettingsBuilder.get(DataTier.TIER_PREFERENCE);
-                if (DataTier.parseTierList(currentTierPreference).isEmpty()) {
+                if (preferredTiers.isEmpty()) {
                     String newTierPreference = isDataStreamIndex ? DataTier.DATA_HOT : DataTier.DATA_CONTENT;
                     logger.debug("enforcing default [{}] setting for [{}] creation, replacing [{}] with [{}]",
                         DataTier.TIER_PREFERENCE, request.index(), currentTierPreference, newTierPreference);
                     indexSettingsBuilder.put(DataTier.TIER_PREFERENCE, newTierPreference);
                 }
+            } else {
+                // if we're not enforcing the tier preference, then maybe warn
+                if (preferredTiers.isEmpty()) {
+                    if (DataTier.dataNodesWithoutAllDataRoles(currentState).isEmpty() == false) {
+                        DEPRECATION_LOGGER.warn(DeprecationCategory.INDICES /*maybe OTHER? */, "index_without_tier_preference",
+                            "[{}] creating index with an empty [{}] setting, and TODO TODO TODO",
+                            request.index(), DataTier.TIER_PREFERENCE);
+                    }
+                }
             }
         }
 

server/src/main/java/org/elasticsearch/cluster/routing/allocation/DataTier.java

@@ -10,6 +10,7 @@
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.cluster.node.DiscoveryNodeRole;
@@ -28,6 +29,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * The {@code DataTier} class encapsulates the formalization of the "content",
@@ -266,4 +268,26 @@ public Iterator<Setting<?>> settings() {
             return dependencies.iterator();
         }
     }
+
+    /**
+     * Checks each data node in the cluster state to see whether it has the explicit data role or if it has
+     * all data tiers (e.g. 'data_hot', 'data_warm', etc). The former condition being treated as a shortcut
+     * for the latter condition (see DataTierAllocationDecider#allocationAllowed(String, Set)) for details,
+     * as well as the various DataTier#isFooNode(DiscoveryNode) methods.
+     *
+     * @param clusterState the cluster state
+     * @return a set of data nodes that do not have all data roles
+     */
+    public static Set<DiscoveryNode> dataNodesWithoutAllDataRoles(ClusterState clusterState) {
+        return clusterState.getNodes().getDataNodes().values().stream()
+            .filter(node -> {
+                Set<String> roles = node.getRoles().stream()
+                    .map(DiscoveryNodeRole::roleName)
+                    .collect(Collectors.toSet());
+
+                return roles.contains(DiscoveryNodeRole.DATA_ROLE.roleName()) == false &&
+                    roles.containsAll(ALL_DATA_TIERS) == false;
+            })
+            .collect(Collectors.toSet());
+    }
 }

server/src/test/java/org/elasticsearch/cluster/metadata/MetadataCreateIndexServiceTests.java

@@ -27,6 +27,7 @@
 import org.elasticsearch.cluster.routing.RoutingTable;
 import org.elasticsearch.cluster.routing.allocation.AllocationService;
 import org.elasticsearch.cluster.routing.allocation.DataTier;
+import org.elasticsearch.cluster.routing.allocation.DataTierTests;
 import org.elasticsearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
 import org.elasticsearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.elasticsearch.cluster.routing.allocation.decider.MaxRetryAllocationDecider;
@@ -1102,6 +1103,16 @@ null, Settings.EMPTY, IndexScopedSettings.DEFAULT_SCOPED_SETTINGS, randomShardLi
             "as it offers superior or equivalent performance to [simplefs].");
     }
 
+    public void testDeprecateNoTierPreference() {
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test");
+        ClusterState clusterState = DataTierTests.clusterStateWithoutAllDataRoles();
+        aggregateIndexSettings(clusterState, request, Settings.EMPTY,
+            null, Settings.EMPTY, IndexScopedSettings.DEFAULT_SCOPED_SETTINGS, randomShardLimitService(),
+            Collections.emptySet(), false);
+        assertWarnings("[test] creating index with an empty [index.routing.allocation.include._tier_preference] setting, " +
+            "and TODO TODO TODO");
+    }
+
     private IndexTemplateMetadata addMatchingTemplate(Consumer<IndexTemplateMetadata.Builder> configurator) {
         IndexTemplateMetadata.Builder builder = templateMetadataBuilder("template1", "te*");
         configurator.accept(builder);

server/src/test/java/org/elasticsearch/cluster/routing/allocation/DataTierTests.java

@@ -9,6 +9,7 @@
 package org.elasticsearch.cluster.routing.allocation;
 
 import org.elasticsearch.Version;
+import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.cluster.node.DiscoveryNodeRole;
 import org.elasticsearch.cluster.node.DiscoveryNodes;
@@ -27,7 +28,9 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
+import static org.elasticsearch.cluster.routing.allocation.DataTier.ALL_DATA_TIERS;
 import static org.elasticsearch.cluster.routing.allocation.DataTier.DATA_COLD;
 import static org.elasticsearch.cluster.routing.allocation.DataTier.DATA_HOT;
 import static org.elasticsearch.cluster.routing.allocation.DataTier.DATA_WARM;
@@ -139,6 +142,35 @@ public void testGetPreferredTiersConfiguration() {
         assertThat(exception.getMessage(), is("invalid data tier [no_tier]"));
     }
 
+    public static ClusterState clusterStateWithoutAllDataRoles() {
+        Set<DiscoveryNodeRole> allDataRoles = new HashSet<>(DiscoveryNodeRole.BUILT_IN_ROLES).stream()
+            .filter(role -> ALL_DATA_TIERS.contains(role.roleName())).collect(Collectors.toSet());
+
+        DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
+        List<DiscoveryNode> nodesList = org.elasticsearch.core.List.of(
+            newNode(0, org.elasticsearch.core.Map.of(), org.elasticsearch.core.Set.of(DiscoveryNodeRole.MASTER_ROLE)),
+            newNode(1, org.elasticsearch.core.Map.of(), org.elasticsearch.core.Set.of(DiscoveryNodeRole.DATA_ROLE)),
+            newNode(2, org.elasticsearch.core.Map.of(), allDataRoles),
+            newNode(3, org.elasticsearch.core.Map.of(), org.elasticsearch.core.Set.of(DiscoveryNodeRole.DATA_FROZEN_NODE_ROLE))
+        );
+        for (DiscoveryNode node : nodesList) {
+            discoBuilder = discoBuilder.add(node);
+        }
+        discoBuilder.localNodeId(randomFrom(nodesList).getId());
+        discoBuilder.masterNodeId(randomFrom(nodesList).getId());
+
+        return ClusterState.builder(ClusterState.EMPTY_STATE).nodes(discoBuilder.build()).build();
+    }
+
+    public void testDataNodesWithoutAllDataRoles() {
+        ClusterState clusterState = clusterStateWithoutAllDataRoles();
+        Set<DiscoveryNode> nodes = DataTier.dataNodesWithoutAllDataRoles(clusterState);
+        assertEquals(1, nodes.size());
+        DiscoveryNode node = nodes.iterator().next();
+        assertEquals("name_3", node.getName());
+        assertEquals(org.elasticsearch.core.Set.of(DiscoveryNodeRole.DATA_FROZEN_NODE_ROLE), node.getRoles());
+    }
+
     private static DiscoveryNodes buildDiscoveryNodes() {
         int numNodes = randomIntBetween(3, 15);
         DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();

server/src/test/java/org/elasticsearch/cluster/routing/allocation/FailedNodeRoutingTests.java

@@ -132,7 +132,8 @@ public void testRandomClusterPromotesNewestReplica() throws InterruptedException
             String name = "index_" + randomAlphaOfLength(8).toLowerCase(Locale.ROOT);
             Settings.Builder settingsBuilder = Settings.builder()
                 .put(SETTING_NUMBER_OF_SHARDS, randomIntBetween(1, 4))
-                .put(SETTING_NUMBER_OF_REPLICAS, randomIntBetween(2, 4));
+                .put(SETTING_NUMBER_OF_REPLICAS, randomIntBetween(2, 4))
+                .put(DataTier.TIER_PREFERENCE, DataTier.DATA_CONTENT);
             CreateIndexRequest request = new CreateIndexRequest(name, settingsBuilder.build()).waitForActiveShards(ActiveShardCount.NONE);
             state = cluster.createIndex(state, request);
             assertTrue(state.metadata().hasIndex(name));

server/src/test/java/org/elasticsearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java

@@ -32,6 +32,7 @@
 import org.elasticsearch.cluster.routing.RoutingTable;
 import org.elasticsearch.cluster.routing.ShardRouting;
 import org.elasticsearch.cluster.routing.ShardRoutingState;
+import org.elasticsearch.cluster.routing.allocation.DataTier;
 import org.elasticsearch.cluster.routing.allocation.FailedShard;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.UUIDs;
@@ -341,7 +342,8 @@ public ClusterState randomlyUpdateClusterState(ClusterState state,
             }
             String name = "index_" + randomAlphaOfLength(15).toLowerCase(Locale.ROOT);
             Settings.Builder settingsBuilder = Settings.builder()
-                .put(SETTING_NUMBER_OF_SHARDS, randomIntBetween(1, 3));
+                .put(SETTING_NUMBER_OF_SHARDS, randomIntBetween(1, 3))
+                .put(DataTier.TIER_PREFERENCE, DataTier.DATA_CONTENT);
             if (randomBoolean()) {
                 int min = randomInt(2);
                 int max = min + randomInt(3);

x-pack/plugin/deprecation/src/main/java/org/elasticsearch/xpack/deprecation/DeprecationChecks.java

@@ -13,9 +13,9 @@
 import org.elasticsearch.common.settings.Setting;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.license.XPackLicenseState;
-import org.elasticsearch.xpack.core.deprecation.DeprecationIssue;
 import org.elasticsearch.transport.TransportService;
 import org.elasticsearch.xpack.core.XPackSettings;
+import org.elasticsearch.xpack.core.deprecation.DeprecationIssue;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -138,24 +138,25 @@ private DeprecationChecks() {
             ).collect(Collectors.toList());
         }
 
-    static List<Function<IndexMetadata, DeprecationIssue>> INDEX_SETTINGS_CHECKS =
+    static List<IndexDeprecationCheck<ClusterState, IndexMetadata, DeprecationIssue>> INDEX_SETTINGS_CHECKS =
         Collections.unmodifiableList(Arrays.asList(
-            IndexDeprecationChecks::oldIndicesCheck,
-            IndexDeprecationChecks::tooManyFieldsCheck,
-            IndexDeprecationChecks::chainedMultiFieldsCheck,
-            IndexDeprecationChecks::deprecatedDateTimeFormat,
-            IndexDeprecationChecks::translogRetentionSettingCheck,
-            IndexDeprecationChecks::fieldNamesDisabledCheck,
-            IndexDeprecationChecks::checkIndexDataPath,
-            IndexDeprecationChecks::indexingSlowLogLevelSettingCheck,
-            IndexDeprecationChecks::searchSlowLogLevelSettingCheck,
-            IndexDeprecationChecks::storeTypeSettingCheck,
-            IndexDeprecationChecks::checkIndexRoutingRequireSetting,
-            IndexDeprecationChecks::checkIndexRoutingIncludeSetting,
-            IndexDeprecationChecks::checkIndexRoutingExcludeSetting,
-            IndexDeprecationChecks::checkIndexMatrixFiltersSetting,
-            IndexDeprecationChecks::checkGeoShapeMappings,
-            IndexDeprecationChecks::frozenIndexSettingCheck
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.oldIndicesCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.tooManyFieldsCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.chainedMultiFieldsCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.deprecatedDateTimeFormat(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.translogRetentionSettingCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.fieldNamesDisabledCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.checkIndexDataPath(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.indexingSlowLogLevelSettingCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.searchSlowLogLevelSettingCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.storeTypeSettingCheck(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.checkIndexRoutingRequireSetting(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.checkIndexRoutingIncludeSetting(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.checkIndexRoutingExcludeSetting(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.checkIndexMatrixFiltersSetting(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.checkGeoShapeMappings(indexMetadata),
+            (clusterState, indexMetadata) -> IndexDeprecationChecks.frozenIndexSettingCheck(indexMetadata),
+            IndexDeprecationChecks::emptyDataTierPreferenceCheck
         ));
 
     /**
@@ -174,4 +175,9 @@ static <T> List<DeprecationIssue> filterChecks(List<T> checks, Function<T, Depre
     public interface NodeDeprecationCheck<A, B, C, D, R> {
         R apply(A first, B second, C third, D fourth);
     }
+
+    @FunctionalInterface
+    public interface IndexDeprecationCheck<A, B, R> {
+        R apply(A first, B second);
+    }
 }

x-pack/plugin/deprecation/src/main/java/org/elasticsearch/xpack/deprecation/DeprecationInfoAction.java

@@ -25,9 +25,9 @@
 import org.elasticsearch.common.regex.Regex;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.set.Sets;
+import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.xcontent.ToXContentObject;
 import org.elasticsearch.xcontent.XContentBuilder;
-import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.xpack.core.deprecation.DeprecationIssue;
 
 import java.io.IOException;
@@ -198,14 +198,16 @@ public int hashCode() {
          * @param clusterSettingsChecks The list of cluster-level checks
          * @return The list of deprecation issues found in the cluster
          */
-        public static DeprecationInfoAction.Response from(ClusterState state,
-                                                          IndexNameExpressionResolver indexNameExpressionResolver,
-                                                          Request request,
-                                                          NodesDeprecationCheckResponse nodeDeprecationResponse,
-                                                          List<Function<IndexMetadata, DeprecationIssue>> indexSettingsChecks,
-                                                          List<Function<ClusterState, DeprecationIssue>> clusterSettingsChecks,
-                                                          Map<String, List<DeprecationIssue>> pluginSettingIssues,
-                                                          List<String> skipTheseDeprecatedSettings) {
+        public static DeprecationInfoAction.Response from(
+            ClusterState state,
+            IndexNameExpressionResolver indexNameExpressionResolver,
+            Request request,
+            NodesDeprecationCheckResponse nodeDeprecationResponse,
+            List<DeprecationChecks.IndexDeprecationCheck<ClusterState, IndexMetadata, DeprecationIssue>> indexSettingsChecks,
+            List<Function<ClusterState, DeprecationIssue>> clusterSettingsChecks,
+            Map<String, List<DeprecationIssue>> pluginSettingIssues,
+            List<String> skipTheseDeprecatedSettings
+        ) {
             // Allow system index access here to prevent deprecation warnings when we call this API
             String[] concreteIndexNames = indexNameExpressionResolver.concreteIndexNamesWithSystemIndexAccess(state, request);
             ClusterState stateWithSkippedSettingsRemoved = removeSkippedSettings(state, concreteIndexNames, skipTheseDeprecatedSettings);
@@ -217,7 +219,7 @@ public static DeprecationInfoAction.Response from(ClusterState state,
             for (String concreteIndex : concreteIndexNames) {
                 IndexMetadata indexMetadata = stateWithSkippedSettingsRemoved.getMetadata().index(concreteIndex);
                 List<DeprecationIssue> singleIndexIssues = filterChecks(indexSettingsChecks,
-                    c -> c.apply(indexMetadata));
+                    c -> c.apply(state, indexMetadata));
                 if (singleIndexIssues.size() > 0) {
                     indexSettingsIssues.put(concreteIndex, singleIndexIssues);
                 }

x-pack/plugin/deprecation/src/main/java/org/elasticsearch/xpack/deprecation/IndexDeprecationChecks.java

@@ -8,20 +8,22 @@
 
 
 import org.elasticsearch.Version;
+import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.MappingMetadata;
+import org.elasticsearch.cluster.routing.allocation.DataTier;
 import org.elasticsearch.common.joda.JodaDeprecationPatterns;
 import org.elasticsearch.common.settings.Setting;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.index.IndexModule;
 import org.elasticsearch.index.IndexSettings;
 import org.elasticsearch.index.IndexingSlowLog;
-import org.elasticsearch.index.mapper.GeoShapeFieldMapper;
-import org.elasticsearch.index.engine.frozen.FrozenEngine;
-import org.elasticsearch.xpack.core.deprecation.DeprecationIssue;
 import org.elasticsearch.index.SearchSlowLog;
 import org.elasticsearch.index.SlowLogLevel;
+import org.elasticsearch.index.engine.frozen.FrozenEngine;
+import org.elasticsearch.index.mapper.GeoShapeFieldMapper;
 import org.elasticsearch.search.SearchModule;
+import org.elasticsearch.xpack.core.deprecation.DeprecationIssue;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -438,4 +440,17 @@ static DeprecationIssue frozenIndexSettingCheck(IndexMetadata indexMetadata) {
         }
         return null;
     }
+
+    static DeprecationIssue emptyDataTierPreferenceCheck(ClusterState clusterState, IndexMetadata indexMetadata) {
+        if (DataTier.dataNodesWithoutAllDataRoles(clusterState).isEmpty() == false) {
+            final List<String> tierPreference = DataTier.parseTierList(DataTier.TIER_PREFERENCE_SETTING.get(indexMetadata.getSettings()));
+            if (tierPreference.isEmpty()) {
+                return new DeprecationIssue(DeprecationIssue.Level.CRITICAL,
+                    "some message here",
+                    "https://www.elastic.co/some/url/here.html",
+                    "some details here", false, null);
+            }
+        }
+        return null;
+    }
 }