[ILM] Data tier notices should reflect tier preferences

x-pack/plugins/index_lifecycle_management/__jest__/components/edit_policy.test.tsx

@@ -503,6 +503,30 @@ describe('edit policy', () => {
       expect(rendered.find('.euiLoadingSpinner').exists()).toBeFalsy();
       expect(findTestSubject(rendered, 'defaultAllocationWarning').exists()).toBeTruthy();
     });
+    test('should show default allocation notice when hot tier exists, but not warm tier', async () => {
+      http.setupNodeListResponse({
+        nodesByAttributes: {},
+        nodesByRoles: { data_hot: ['test'], data_cold: ['test'] },
+      });
+      const rendered = mountWithIntl(component);
+      noRollover(rendered);
+      setPolicyName(rendered, 'mypolicy');
+      await activatePhase(rendered, 'warm');
+      expect(rendered.find('.euiLoadingSpinner').exists()).toBeFalsy();
+      expect(findTestSubject(rendered, 'defaultAllocationNotice').exists()).toBeTruthy();
+    });
+    test('should not show default allocation notice when node with "data" role exists', async () => {
+      http.setupNodeListResponse({
+        nodesByAttributes: {},
+        nodesByRoles: { data: ['test'] },
+      });
+      const rendered = mountWithIntl(component);
+      noRollover(rendered);
+      setPolicyName(rendered, 'mypolicy');
+      await activatePhase(rendered, 'warm');
+      expect(rendered.find('.euiLoadingSpinner').exists()).toBeFalsy();
+      expect(findTestSubject(rendered, 'defaultAllocationNotice').exists()).toBeFalsy();
+    });
   });
   describe('cold phase', () => {
     beforeEach(() => {
@@ -610,6 +634,30 @@ describe('edit policy', () => {
       expect(rendered.find('.euiLoadingSpinner').exists()).toBeFalsy();
       expect(findTestSubject(rendered, 'defaultAllocationWarning').exists()).toBeTruthy();
     });
+    test('should show default allocation notice when warm or hot tiers exists, but not cold tier', async () => {
+      http.setupNodeListResponse({
+        nodesByAttributes: {},
+        nodesByRoles: { data_hot: ['test'], data_warm: ['test'] },
+      });
+      const rendered = mountWithIntl(component);
+      noRollover(rendered);
+      setPolicyName(rendered, 'mypolicy');
+      await activatePhase(rendered, 'cold');
+      expect(rendered.find('.euiLoadingSpinner').exists()).toBeFalsy();
+      expect(findTestSubject(rendered, 'defaultAllocationNotice').exists()).toBeTruthy();
+    });
+    test('should not show default allocation notice when node with "data" role exists', async () => {
+      http.setupNodeListResponse({
+        nodesByAttributes: {},
+        nodesByRoles: { data: ['test'] },
+      });
+      const rendered = mountWithIntl(component);
+      noRollover(rendered);
+      setPolicyName(rendered, 'mypolicy');
+      await activatePhase(rendered, 'cold');
+      expect(rendered.find('.euiLoadingSpinner').exists()).toBeFalsy();
+      expect(findTestSubject(rendered, 'defaultAllocationNotice').exists()).toBeFalsy();
+    });
   });
   describe('delete phase', () => {
     test('should allow 0 for phase timing', async () => {

x-pack/plugins/index_lifecycle_management/common/constants/data_tiers.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+// Order of node roles matters here, the warm phase prefers allocating data
+// to the data_warm role.
+import { NodeDataRole, PhaseWithAllocation } from '../types';
+
+const WARM_PHASE_NODE_PREFERENCE: NodeDataRole[] = ['data_warm', 'data_hot'];
+
+const COLD_PHASE_NODE_PREFERENCE: NodeDataRole[] = ['data_cold', 'data_warm', 'data_hot'];
+
+export const phaseToNodePreferenceMap: Record<PhaseWithAllocation, NodeDataRole[]> = Object.freeze({
+  warm: WARM_PHASE_NODE_PREFERENCE,
+  cold: COLD_PHASE_NODE_PREFERENCE,
+});

x-pack/plugins/index_lifecycle_management/common/constants/index.ts

@@ -7,6 +7,8 @@
 import { i18n } from '@kbn/i18n';
 import { LicenseType } from '../../../licensing/common/types';
 
+export { phaseToNodePreferenceMap } from './data_tiers';
+
 const basicLicense: LicenseType = 'basic';
 
 export const PLUGIN = {

x-pack/plugins/index_lifecycle_management/common/types/api.ts

@@ -4,9 +4,9 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-export type NodeDataRole = 'data' | 'data_hot' | 'data_warm' | 'data_cold' | 'data_frozen';
+import { NodeDataRoleWithCatchAll } from '.';
 
 export interface ListNodesRouteResponse {
   nodesByAttributes: { [attributePair: string]: string[] };
-  nodesByRoles: { [role in NodeDataRole]?: string[] };
+  nodesByRoles: { [role in NodeDataRoleWithCatchAll]?: string[] };
 }

x-pack/plugins/index_lifecycle_management/common/types/index.ts

@@ -7,3 +7,10 @@
 export * from './api';
 
 export * from './policies';
+
+/**
+ * These roles reflect how nodes are stratified into different data tiers. The "data" role
+ * is a catch-all that can be used to store data in any phase.
+ */
+export type NodeDataRole = 'data_hot' | 'data_warm' | 'data_cold';
+export type NodeDataRoleWithCatchAll = 'data' | NodeDataRole;

x-pack/plugins/index_lifecycle_management/public/application/lib/data_tiers/determine_allocation_node_role.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import {
+  NodeDataRole,
+  ListNodesRouteResponse,
+  PhaseWithAllocation,
+} from '../../../../common/types';
+
+import { phaseToNodePreferenceMap } from '../../../../common/constants';
+
+export type AllocationNodeRole = NodeDataRole | 'none';
+
+/**
+ * Given a phase and current cluster node roles, determine which nodes the phase
+ * will allocate data to. For instance, for the warm phase, with warm
+ * tier nodes, we would expect "data_warm".
+ *
+ * If no nodes can be identified for allocation (very special case) then
+ * we return "none".
+ */
+export const determineAllocationNodeRole = (
+  phase: PhaseWithAllocation,
+  nodesByRoles: ListNodesRouteResponse['nodesByRoles']
+): AllocationNodeRole => {
+  // The 'data' role covers all node roles, so if we have at least one node with the data role
+  // we can allocate to our first preference.
+  if (nodesByRoles.data?.length) {
+    return phaseToNodePreferenceMap[phase][0];
+  }
+
+  const preferredNodeRoles = phaseToNodePreferenceMap[phase];
+  return preferredNodeRoles.find((role) => Boolean(nodesByRoles[role]?.length)) ?? 'none';
+};

x-pack/plugins/index_lifecycle_management/public/application/lib/data_tiers/index.ts

@@ -6,4 +6,4 @@
 
 export * from './determine_allocation_type';
 
-export * from './check_phase_compatibility';
+export * from './determine_allocation_node_role';

x-pack/plugins/index_lifecycle_management/public/application/lib/data_tiers/is_node_role_first_preference.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { NodeDataRole, PhaseWithAllocation } from '../../../../common/types';
+import { phaseToNodePreferenceMap } from '../../../../common/constants';
+
+export const isNodeRoleFirstPreference = (phase: PhaseWithAllocation, nodeRole: NodeDataRole) => {
+  return phaseToNodePreferenceMap[phase][0] === nodeRole;
+};

x-pack/plugins/index_lifecycle_management/public/application/sections/edit_policy/components/data_tier_allocation/default_allocation_notice.tsx

@@ -0,0 +1,109 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { i18n } from '@kbn/i18n';
+import React, { FunctionComponent } from 'react';
+import { EuiCallOut, EuiSpacer } from '@elastic/eui';
+
+import { PhaseWithAllocation, NodeDataRole } from '../../../../../../common/types';
+
+import { AllocationNodeRole } from '../../../../lib';
+
+const i18nTextsNodeRoleToDataTier: Record<NodeDataRole, string> = {
+  data_hot: i18n.translate('xpack.indexLifecycleMgmt.common.dataTier.hot', {
+    defaultMessage: 'hot',
+  }),
+  data_warm: i18n.translate('xpack.indexLifecycleMgmt.common.dataTier.warm', {
+    defaultMessage: 'warm',
+  }),
+  data_cold: i18n.translate('xpack.indexLifecycleMgmt.common.dataTier.cold', {
+    defaultMessage: 'cold',
+  }),
+};
+
+const i18nTexts = {
+  notice: {
+    warm: {
+      title: i18n.translate(
+        'xpack.indexLifecycleMgmt.warmPhase.dataTier.defaultAllocationNotice.warm.title',
+        { defaultMessage: 'No nodes assigned to the warm tier' }
+      ),
+      body: (nodeRole: NodeDataRole) =>
+        i18n.translate('xpack.indexLifecycleMgmt.warmPhase.dataTier.defaultAllocationNotice.warm', {
+          defaultMessage: 'Data in the warm phase will be allocated to {tier} tier nodes instead.',
+          values: { tier: i18nTextsNodeRoleToDataTier[nodeRole] },
+        }),
+    },
+    cold: {
+      title: i18n.translate(
+        'xpack.indexLifecycleMgmt.warmPhase.dataTier.defaultAllocationNotice.cold.title',
+        { defaultMessage: 'No nodes assigned to the cold tier' }
+      ),
+      body: (nodeRole: NodeDataRole) =>
+        i18n.translate('xpack.indexLifecycleMgmt.warmPhase.dataTier.defaultAllocationNotice.cold', {
+          defaultMessage: 'Data in the cold phase will be allocated to {tier} tier nodes instead.',
+          values: { tier: i18nTextsNodeRoleToDataTier[nodeRole] },
+        }),
+    },
+  },
+  warning: {
+    warm: {
+      title: i18n.translate(
+        'xpack.indexLifecycleMgmt.warmPhase.dataTier.defaultAllocationNotAvailableTitle',
+        { defaultMessage: 'No nodes assigned to the warm tier' }
+      ),
+      body: i18n.translate(
+        'xpack.indexLifecycleMgmt.warmPhase.dataTier.defaultAllocationNotAvailableBody',
+        {
+          defaultMessage:
+            'Assign at least one node to the warm or hot tier to use role-based allocation. The policy will fail to complete allocation if there are no available nodes.',
+        }
+      ),
+    },
+    cold: {
+      title: i18n.translate(
+        'xpack.indexLifecycleMgmt.coldPhase.dataTier.defaultAllocationNotAvailableTitle',
+        { defaultMessage: 'No nodes assigned to the cold tier' }
+      ),
+      body: i18n.translate(
+        'xpack.indexLifecycleMgmt.coldPhase.dataTier.defaultAllocationNotAvailableBody',
+        {
+          defaultMessage:
+            'Assign at least one node to the cold, warm, or hot tier to use role-based allocation. The policy will fail to complete allocation if there are no available nodes.',
+        }
+      ),
+    },
+  },
+};
+
+interface Props {
+  phase: PhaseWithAllocation;
+  targetNodeRole: AllocationNodeRole;
+}
+
+export const DefaultAllocationNotice: FunctionComponent<Props> = ({ phase, targetNodeRole }) => {
+  const content =
+    targetNodeRole === 'none' ? (
+      <EuiCallOut
+        data-test-subj="defaultAllocationWarning"
+        title={i18nTexts.warning[phase].title}
+        color="warning"
+      >
+        {i18nTexts.warning[phase].body}
+      </EuiCallOut>
+    ) : (
+      <EuiCallOut data-test-subj="defaultAllocationNotice" title={i18nTexts.notice[phase].title}>
+        {i18nTexts.notice[phase].body(targetNodeRole)}
+      </EuiCallOut>
+    );
+
+  return (
+    <>
+      <EuiSpacer size="s" />
+      {content}
+    </>
+  );
+};

x-pack/plugins/index_lifecycle_management/public/application/sections/edit_policy/components/data_tier_allocation/index.ts

@@ -8,5 +8,5 @@ export { NodesDataProvider } from './node_data_provider';
 export { NodeAllocation } from './node_allocation';
 export { NodeAttrsDetails } from './node_attrs_details';
 export { DataTierAllocation } from './data_tier_allocation';
-export { DefaultAllocationWarning } from './default_allocation_warning';
+export { DefaultAllocationNotice } from './default_allocation_notice';
 export { NoNodeAttributesWarning } from './no_node_attributes_warning';

x-pack/plugins/index_lifecycle_management/public/application/sections/edit_policy/components/index.ts

@@ -18,7 +18,7 @@ export {
   NodeAllocation,
   NodeAttrsDetails,
   NodesDataProvider,
-  DefaultAllocationWarning,
+  DefaultAllocationNotice,
 } from './data_tier_allocation';
 export { DescribedFormField } from './described_form_field';
 export { Forcemerge } from './forcemerge';