Add clear deprecation around legacy role settings

We've deprecated the legacy role settings. Individually, when you use
such a setting, you will get an individual log message informing you
that you've used a legacy role setting. What the deprecation does not
tell you though, is the equivalent node.roles setting that you should be
using to achieve identical functionality to what you have today. This
creates a bad user experience. Suppose that you've configured a node
(e.g., node.data: true, node.ingest: false, node.master: false,
node.remote_cluster_client: false), but never explicitly set the legacy
node.transform setting. In this case, we'll use the default value of
true. You see the deprecation message informing you that node.data,
node.ingest, node.master, and node.remote_cluster_client are
deprecated. So you do some searching in the docs and discover the
node.roles setting. So you dutifully set node.roles: [data] because this
is the only legacy role setting that you've enabled. Well, now you're
having a bad time because this will also disable the transform role,
which was implicitly enabled. This commit provides a cleared deprecation
message in this case:

legacy role settings [node.data, node.ingest,
node.remote_cluster_client, node.master] are deprecated, use
[node.roles=[transform, data_frozen, data_hot, data_content, data_warm,
data, data_cold]

This should help users transition between the legacy role settings and
the new role setting.

Author: jasontedor

server/src/main/java/org/elasticsearch/cluster/node/DiscoveryNode.java

@@ -206,7 +206,10 @@ public static DiscoveryNode createLocal(Settings settings, TransportAddress publ
 
     /** extract node roles from the given settings */
     public static Set<DiscoveryNodeRole> getRolesFromSettings(final Settings settings) {
-        if (NODE_ROLES_SETTING.exists(settings)) {
+        // are any legacy settings in use?
+        boolean usesLegacySettings =
+            getPossibleRoles().stream().anyMatch(s -> s.legacySetting() != null && s.legacySetting().exists(settings));
+        if (NODE_ROLES_SETTING.exists(settings) || usesLegacySettings == false) {
             validateLegacySettings(settings, roleMap);
             return Set.copyOf(NODE_ROLES_SETTING.get(settings));
         } else {

server/src/main/java/org/elasticsearch/node/Node.java

@@ -52,6 +52,7 @@
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.StopWatch;
 import org.elasticsearch.common.breaker.CircuitBreaker;
+import org.elasticsearch.common.collect.Tuple;
 import org.elasticsearch.common.component.Lifecycle;
 import org.elasticsearch.common.component.LifecycleComponent;
 import org.elasticsearch.common.inject.Injector;
@@ -181,6 +182,7 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
@@ -338,11 +340,36 @@ protected Node(final Environment initialEnvironment,
             this.environment = new Environment(settings, initialEnvironment.configFile());
             Environment.assertEquivalent(initialEnvironment, this.environment);
             nodeEnvironment = new NodeEnvironment(tmpSettings, environment);
-            logger.info("node name [{}], node ID [{}], cluster name [{}], roles {}",
-                NODE_NAME_SETTING.get(tmpSettings), nodeEnvironment.nodeId(), ClusterName.CLUSTER_NAME_SETTING.get(tmpSettings).value(),
-                DiscoveryNode.getRolesFromSettings(settings).stream()
-                    .map(DiscoveryNodeRole::roleName)
-                    .collect(Collectors.toCollection(LinkedHashSet::new)));
+            final Set<String> roleNames = DiscoveryNode.getRolesFromSettings(settings).stream()
+                .map(DiscoveryNodeRole::roleName)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+            logger.info(
+                "node name [{}], node ID [{}], cluster name [{}], roles {}",
+                NODE_NAME_SETTING.get(tmpSettings),
+                nodeEnvironment.nodeId(),
+                ClusterName.CLUSTER_NAME_SETTING.get(tmpSettings).value(),
+                roleNames
+            );
+            {
+                // are there any legacy settings in use?
+                final List<Tuple<DiscoveryNodeRole, Setting<Boolean>>> maybeLegacyRoleSettings = DiscoveryNode.getPossibleRoles()
+                    .stream()
+                    .filter(s -> s.legacySetting() != null)
+                    .map(s -> Tuple.tuple(s, s.legacySetting()))
+                    .filter(t -> t.v2().exists(settings))
+                    .collect(Collectors.toUnmodifiableList());
+                if (maybeLegacyRoleSettings.isEmpty() == false) {
+                    final String legacyRoleSettingNames =
+                        maybeLegacyRoleSettings.stream().map(Tuple::v2).map(Setting::getKey).collect(Collectors.joining(", "));
+                    deprecationLogger.deprecate(
+                        DeprecationCategory.SETTINGS,
+                        "legacy role settings",
+                        "legacy role settings [{}] are deprecated, use [node.roles={}]",
+                        legacyRoleSettingNames,
+                        roleNames
+                    );
+                }
+            }
             resourcesToClose.add(nodeEnvironment);
             localNodeFactory = new LocalNodeFactory(settings, nodeEnvironment.nodeId());