@cloud-ru/uikit-product-calculator 0.33.3

package/src/config/platforms/advanced/product-config/AdvancedElasticLoadBalance.tsx

@@ -0,0 +1,252 @@
+import { ArrayControl, CONTROL, FormConfig, ObjectControl, SegmentedControl } from '../../../../components';
+import styles from '../../../styles.module.scss';
+import { generateBaseItems, getEip } from '../../../utils';
+
+const loadBalancerTypeItem = {
+  Shared: 'Shared',
+  Dedicated: 'Dedicated',
+};
+
+const balancerWorkLevelItem = {
+  HTTP: 'HTTP/HTTPS L7',
+  TCP: 'TCP/UDP L4',
+};
+
+const getElbConfigControls = (
+  prefix: string = 'elb',
+): {
+  loadBalancerType: SegmentedControl;
+  accessibilityZoneQuantity: SegmentedControl;
+  dedicatedObj: ObjectControl;
+} => {
+  const accessorKey = {
+    loadBalancerType: `${prefix}.type`,
+    accessibilityZoneQuantity: `${prefix}.accessibilityZoneQuantity`,
+    balancerWorkLevel: `${prefix}.balancerWorkLevel`,
+    lcu: `${prefix}.lcu`,
+  };
+
+  return {
+    loadBalancerType: {
+      type: CONTROL.Segmented,
+      accessorKey: accessorKey.loadBalancerType,
+      defaultValue: loadBalancerTypeItem.Shared,
+      items: [
+        {
+          value: loadBalancerTypeItem.Shared,
+          label: 'Общий (бесплатный)',
+        },
+        {
+          value: loadBalancerTypeItem.Dedicated,
+          label: 'Выделенный',
+        },
+      ],
+      decoratorProps: {
+        label: 'Тип балансировщика нагрузки',
+        labelTooltip: (
+          <ul className={styles.tip}>
+            <li>
+              Общий балансировщик нагрузки предоставляется бесплатно, ресурсы развертываются в кластерном режиме и
+              распределяются между балансировщиками нагрузки
+            </li>
+            <li>
+              Выделенный балансировщик нагрузки поддерживает двойной стек IPv4/IPv6 и развертывание в разных зонах
+              доступности, несколько спецификаций обеспечивают гибкую настройку
+            </li>
+          </ul>
+        ),
+      },
+    },
+    accessibilityZoneQuantity: {
+      type: CONTROL.Segmented,
+      accessorKey: accessorKey.accessibilityZoneQuantity,
+      defaultValue: '1',
+      items: generateBaseItems([1, 2, 3, 4]),
+      watchedControls: { loadBalancerType: accessorKey.loadBalancerType },
+      relateFn: ({ loadBalancerType }) => {
+        if (loadBalancerType === loadBalancerTypeItem.Shared) {
+          return {
+            uiProps: {
+              visible: false,
+            },
+          };
+        }
+      },
+      decoratorProps: {
+        label: 'Количество зон доступности развертывания',
+      },
+    },
+    dedicatedObj: {
+      type: CONTROL.Object,
+      ui: [['balancerWorkLevel', 'lcu']],
+      visible: true,
+      watchedControls: { loadBalancerType: accessorKey.loadBalancerType },
+      relateFn: ({ loadBalancerType }) => {
+        if (loadBalancerType === loadBalancerTypeItem.Shared) {
+          return {
+            visible: false,
+          };
+        }
+      },
+      controls: {
+        balancerWorkLevel: {
+          type: CONTROL.SelectSingle,
+          accessorKey: accessorKey.balancerWorkLevel,
+          defaultValue: balancerWorkLevelItem.HTTP,
+          items: [
+            { value: balancerWorkLevelItem.HTTP, label: 'Балансировка нагрузки приложений (HTTP/HTTPS)' },
+            { value: balancerWorkLevelItem.TCP, label: 'Балансировка сетевой нагрузки (TCP/UDP)' },
+          ],
+          decoratorProps: {
+            label: 'Уровень работы',
+            labelTooltip: (
+              <ul className={styles.tip}>
+                <li>
+                  Запросы направляются на разные внутренние серверы в зависимости от содержимого запроса. Балансировка
+                  нагрузки приложений идеально подходит для сценариев, связанных с трафиком HTTP/HTTPS, например для
+                  веб-приложений.
+                </li>
+                <li>
+                  Базовая маршрутизация запросов выполняется для трафика TCP/UDP на уровне передачи. Балансировка
+                  сетевой нагрузки идеально подходит для таких сценариев, как передача файлов, обмен мгновенными
+                  сообщениями и потоковое видео.
+                </li>
+              </ul>
+            ),
+          },
+        },
+        lcu: {
+          type: CONTROL.Segmented,
+          accessorKey: accessorKey.lcu,
+          defaultValue: '10',
+          items: generateBaseItems([10, 20, 40, 80, 200, 400]),
+          watchedControls: {
+            balancerWorkLevel: accessorKey.balancerWorkLevel,
+          },
+          relateFn: ({ balancerWorkLevel }) => {
+            if (balancerWorkLevel === balancerWorkLevelItem.HTTP) {
+              return {
+                items: generateBaseItems([10, 20, 40, 200, 400]),
+              };
+            }
+          },
+          decoratorProps: {
+            label: 'LCU',
+            labelTooltip: 'Единица ресурса балансировщика нагрузки',
+          },
+        },
+      },
+    },
+  };
+};
+
+const elbTypeControls = getElbConfigControls('configs[0]');
+
+const getArrConfigControl = (multiple?: boolean): ObjectControl => {
+  const { loadBalancerType, accessibilityZoneQuantity, dedicatedObj } = getElbConfigControls();
+
+  return {
+    type: CONTROL.Object,
+    ui: [['loadBalancerType', 'accessibilityZoneQuantity'], 'dedicatedObj'],
+    decoratorProps: multiple ? { label: 'Конфигурация' } : undefined,
+    controls: {
+      loadBalancerType: {
+        ...loadBalancerType,
+        defaultValue: loadBalancerTypeItem.Dedicated,
+        items: [
+          {
+            value: loadBalancerTypeItem.Shared,
+            label: 'Общий (бесплатный)',
+            disabled: multiple || false,
+          },
+          {
+            value: loadBalancerTypeItem.Dedicated,
+            label: 'Выделенный',
+          },
+        ],
+      },
+      accessibilityZoneQuantity,
+      dedicatedObj,
+    },
+  };
+};
+
+const getArrayControl = (multiple?: boolean): ArrayControl => ({
+  type: CONTROL.Array,
+  accessorKey: 'configs',
+  addText: 'Добавить балансировщик',
+  min: 1,
+  max: 3,
+  defaultValue: [],
+  ui: ['config'],
+  controls: {
+    config: getArrConfigControl(multiple),
+  },
+  invertTrashOffset: true,
+});
+
+const accessorKey = {
+  elbType: 'configs[0].elb.type',
+  configs: 'configs',
+};
+
+export const ELASTIC_LOAD_BALANCE_FORM_CONFIG: FormConfig = {
+  ui: ['elbTypeObj', 'arrObj', 'arrMoreObj', 'eipIsNeeded'],
+  controls: {
+    elbTypeObj: {
+      type: CONTROL.Object,
+      ui: ['loadBalancerType'],
+      visible: true,
+      controls: {
+        loadBalancerType: { ...elbTypeControls.loadBalancerType, accessorKey: accessorKey.elbType },
+      },
+      watchedControls: { elbType: accessorKey.elbType },
+      relateFn: ({ elbType }) => {
+        if (elbType === loadBalancerTypeItem.Dedicated) {
+          return {
+            visible: false,
+          };
+        }
+      },
+    },
+    arrObj: {
+      type: CONTROL.Object,
+      ui: ['arr'],
+      controls: {
+        arr: getArrayControl(false),
+      },
+      visible: false,
+      watchedControls: { elbType: accessorKey.elbType, configs: accessorKey.configs },
+      relateFn: ({ elbType, configs }) => {
+        if (elbType === loadBalancerTypeItem.Dedicated && configs.length === 1) {
+          return {
+            visible: true,
+          };
+        }
+      },
+    },
+    arrMoreObj: {
+      type: CONTROL.Object,
+      ui: ['arr'],
+      controls: {
+        arr: getArrayControl(true),
+      },
+      visible: false,
+      watchedControls: { elbType: accessorKey.elbType, configs: accessorKey.configs },
+      relateFn: ({ elbType, configs }) => {
+        if (elbType === loadBalancerTypeItem.Dedicated && configs.length > 1) {
+          return {
+            visible: true,
+          };
+        }
+      },
+    },
+
+    eipIsNeeded: getEip({
+      switchKey: 'eipIsNeeded',
+      velocityKey: 'eip.velocity',
+      specificationKey: 'eip.specification',
+      trafficKey: 'eip.traffic',
+    }),
+  },
+};

package/src/config/platforms/advanced/product-config/AdvancedElasticSearch.ts

@@ -0,0 +1,365 @@
+import {
+  CONTROL,
+  FormConfig,
+  ObjectControl,
+  SelectSingleControl,
+  StepperControl,
+  ToggleObjectControl,
+} from '../../../../components';
+import { TooltipPlacement } from '../../../../components/Controls/types';
+import { AnyType } from '../../../../types';
+import { generateInstanceConfigItems, getDisk } from '../../../utils';
+
+const ServerTypeItem = {
+  ComputeIntensive: 'Compute-intensive',
+  GeneralComputing: 'General computing',
+  MemoryOptimized: 'Memory-optimized',
+};
+
+const serverTypeItems = [
+  {
+    value: ServerTypeItem.ComputeIntensive,
+    label: 'Compute-intensive',
+  },
+  {
+    value: ServerTypeItem.GeneralComputing,
+    label: 'General computing',
+  },
+  {
+    value: ServerTypeItem.MemoryOptimized,
+    label: 'Memory-optimized',
+  },
+];
+
+const InstanceConfigMap: Record<string, [number, number][]> = {
+  [ServerTypeItem.ComputeIntensive]: [
+    [4, 8],
+    [8, 16],
+    [16, 32],
+    [32, 64],
+  ],
+  [ServerTypeItem.GeneralComputing]: [
+    [4, 16],
+    [8, 32],
+    [16, 64],
+    [32, 128],
+  ],
+  [ServerTypeItem.MemoryOptimized]: [
+    [4, 32],
+    [8, 64],
+    [16, 128],
+  ],
+};
+
+const serverTypeInstanceConfigToEvsDiskSpaceMap: Record<string, Record<string, [number, number]>> = {
+  [ServerTypeItem.ComputeIntensive]: {
+    '4 8': [40, 1_500],
+    '8 16': [80, 1_600],
+    '16 32': [100, 3_200],
+    '32 64': [320, 10_240],
+  },
+  [ServerTypeItem.GeneralComputing]: {
+    '4 16': [40, 1_600],
+    '8 32': [80, 3_200],
+    '16 64': [100, 6_400],
+    '32 128': [100, 10_240],
+  },
+  [ServerTypeItem.MemoryOptimized]: {
+    '4 32': [40, 2560],
+    '8 64': [80, 5_120],
+    '16 128': [160, 10_240],
+  },
+};
+
+const baseInstanceConfigItems = generateInstanceConfigItems(InstanceConfigMap[ServerTypeItem.ComputeIntensive]);
+
+type GetNodeConfigProps = {
+  prefix: string;
+  diskProps: {
+    min: number;
+    max: number;
+    defaultValue: number;
+  };
+  nodeCountProps: {
+    min: number;
+    max: number;
+    defaultValue: number;
+  };
+};
+
+function getAccessorKey(prefix: string) {
+  return {
+    serverType: `${prefix}.serverType`,
+    instanceConfig: `${prefix}.instanceConfig`,
+    evsDiskSpace: `${prefix}.evs.systemDisk.diskSpace`,
+    evsDiskSpecification: `${prefix}.evs.systemDisk.specification`,
+    nodeCount: `${prefix}.nodeCount`,
+  };
+}
+
+function getNodeConfigControls({ prefix, diskProps, nodeCountProps }: GetNodeConfigProps): {
+  serverType: SelectSingleControl;
+  instanceConfig: SelectSingleControl;
+  evs: ObjectControl;
+  nodeCount: StepperControl;
+} {
+  const accessorKey = getAccessorKey(prefix);
+
+  return {
+    serverType: {
+      type: CONTROL.SelectSingle,
+      accessorKey: accessorKey.serverType,
+      defaultValue: ServerTypeItem.ComputeIntensive,
+      items: serverTypeItems,
+      decoratorProps: {
+        label: 'Тип сервера',
+      },
+    },
+    instanceConfig: {
+      type: CONTROL.SelectSingle,
+      accessorKey: accessorKey.instanceConfig,
+      defaultValue: baseInstanceConfigItems[0].value,
+      items: baseInstanceConfigItems,
+      decoratorProps: {
+        label: 'Спецификация ноды',
+      },
+      watchedControls: { serverType: accessorKey.serverType },
+      relateFn: ({ serverType }) => ({
+        items: generateInstanceConfigItems(InstanceConfigMap[serverType]),
+      }),
+    },
+    evs: getDisk({
+      space: {
+        accessorKey: accessorKey.evsDiskSpace,
+        label: 'Объем системного диска',
+        defaultValue: diskProps.defaultValue,
+        uiProps: {
+          min: diskProps.min,
+          max: diskProps.max,
+        },
+      },
+      specification: {
+        accessorKey: accessorKey.evsDiskSpecification,
+        defaultValue: 'SSD',
+      },
+    }),
+    nodeCount: {
+      type: CONTROL.Stepper,
+      accessorKey: accessorKey.nodeCount,
+      defaultValue: nodeCountProps.defaultValue,
+      decoratorProps: {
+        label: 'Количество нод',
+      },
+      uiProps: {
+        min: nodeCountProps.min,
+        max: nodeCountProps.max,
+        postfix: 'Шт',
+      },
+    },
+  };
+}
+
+function getNodeConfig(props: GetNodeConfigProps): ObjectControl {
+  const { evs, serverType, instanceConfig, nodeCount } = getNodeConfigControls(props);
+
+  return {
+    type: CONTROL.Object,
+    ui: [
+      ['serverType', 'instanceConfig'],
+      ['evs', 'nodeCount'],
+    ],
+    controls: {
+      serverType,
+      instanceConfig,
+      evs,
+      nodeCount,
+    },
+  };
+}
+
+type GetToggleNodeConfigProps = GetNodeConfigProps & {
+  label: string;
+  labelTooltip: string;
+  labelTooltipPlacement?: TooltipPlacement;
+};
+
+function getToggleNodeConfig({
+  label,
+  labelTooltip,
+  labelTooltipPlacement,
+  ...rest
+}: GetToggleNodeConfigProps): ToggleObjectControl {
+  return {
+    type: CONTROL.ToggleObject,
+    decoratorProps: {
+      label,
+      labelTooltip,
+      labelTooltipPlacement,
+    },
+    switchKey: `${rest.prefix}.isIncluded`,
+    control: getNodeConfig(rest),
+  };
+}
+
+function getBaseNodeConfig(props: GetNodeConfigProps): ObjectControl {
+  const { serverType, instanceConfig, nodeCount } = getNodeConfigControls(props);
+
+  const accessorKey = getAccessorKey(props.prefix);
+
+  return {
+    type: CONTROL.Object,
+    ui: [
+      ['serverType', 'instanceConfig'],
+      ['evs', 'nodeCount'],
+    ],
+    controls: {
+      serverType: {
+        ...serverType,
+        onChangeFn: (value, setValue) => {
+          const arr: [string, AnyType][] = [[accessorKey.serverType, value]];
+          const instanceConfigValue = generateInstanceConfigItems(InstanceConfigMap[value])[0].value;
+
+          arr.push([accessorKey.instanceConfig, instanceConfigValue]);
+          arr.push([accessorKey.evsDiskSpace, 40]);
+
+          setValue(arr);
+        },
+      },
+      instanceConfig: {
+        ...instanceConfig,
+        onChangeFn: (value, setValue) => {
+          const arr: [string, AnyType][] = [[accessorKey.instanceConfig, value]];
+          arr.push([accessorKey.evsDiskSpace, 40]);
+
+          setValue(arr);
+        },
+      },
+      evs: getDisk({
+        space: {
+          accessorKey: accessorKey.evsDiskSpace,
+          label: 'Объем системного диска',
+          defaultValue: props.diskProps.defaultValue,
+          uiProps: {
+            min: props.diskProps.min,
+            max: props.diskProps.max,
+          },
+          watchedControls: { serverType: accessorKey.serverType, instanceConfig: accessorKey.instanceConfig },
+          relateFn: ({ serverType, instanceConfig }) => {
+            const [min, max] = serverTypeInstanceConfigToEvsDiskSpaceMap?.[serverType]?.[instanceConfig] || [];
+
+            if (min || max) {
+              return {
+                uiProps: {
+                  min,
+                  max,
+                },
+              };
+            }
+          },
+        },
+        specification: {
+          accessorKey: accessorKey.evsDiskSpecification,
+          defaultValue: 'SSD',
+        },
+      }),
+      nodeCount,
+    },
+  };
+}
+
+export const ELASTIC_SEARCH_FORM_CONFIG: FormConfig = {
+  ui: ['baseNodeConfig', 'masterNodeConfig', 'clientNodeConfig', 'coldDataNodeConfig', 'internet'],
+  controls: {
+    baseNodeConfig: getBaseNodeConfig({
+      prefix: 'baseNodeConfig',
+      diskProps: {
+        defaultValue: 40,
+        min: 40,
+        max: 1500,
+      },
+      nodeCountProps: {
+        defaultValue: 1,
+        min: 1,
+        max: 200,
+      },
+    }),
+
+    masterNodeConfig: getToggleNodeConfig({
+      label: 'Master node',
+      labelTooltip:
+        'Мастер-узел, который управляет всеми узлами в кластере. Если для хранения и обработки данных требуется 20 или более узлов, рекомендуется включить мастер-узел, чтобы обеспечить стабильную работу кластера',
+      prefix: 'masterNodeConfig',
+      diskProps: {
+        defaultValue: 40,
+        min: 40,
+        max: 40,
+      },
+      nodeCountProps: {
+        defaultValue: 3,
+        min: 3,
+        max: 9,
+      },
+    }),
+
+    clientNodeConfig: getToggleNodeConfig({
+      label: 'Client node',
+      labelTooltip:
+        'Клиент-узел, который позволяет клиентам получать доступ к кластерам и анализировать данные. Если для хранения и обработки данных требуется 20 или более узлов, рекомендуется включить клиент-узел, чтобы обеспечить стабильную работу кластера',
+      prefix: 'clientNodeConfig',
+      diskProps: {
+        defaultValue: 40,
+        min: 40,
+        max: 40,
+      },
+      nodeCountProps: {
+        defaultValue: 1,
+        min: 1,
+        max: 32,
+      },
+    }),
+
+    coldDataNodeConfig: getToggleNodeConfig({
+      label: 'Cold data node',
+      labelTooltip:
+        'Холодный узел, который используется для хранения архивных данных. Если быстрый ответ (получение данных из холодного узла занимает несколько минут) не требуется, используйте узлы данного типа',
+      prefix: 'coldDataNodeConfig',
+      diskProps: {
+        defaultValue: 40,
+        min: 40,
+        max: 1500,
+      },
+      nodeCountProps: {
+        defaultValue: 1,
+        min: 1,
+        max: 32,
+      },
+    }),
+
+    internet: {
+      type: CONTROL.ToggleObject,
+      switchKey: 'internet.isIncluded',
+      decoratorProps: {
+        label: 'Доступ в интернет',
+      },
+      control: {
+        type: CONTROL.Object,
+        ui: [['speed']],
+        controls: {
+          speed: {
+            type: CONTROL.Stepper,
+            accessorKey: 'internet.speed',
+            defaultValue: 100,
+            decoratorProps: {
+              label: 'Скорость',
+            },
+            uiProps: {
+              min: 1,
+              max: 2000,
+              postfix: 'Mбит/сек',
+            },
+          },
+        },
+      },
+    },
+  },
+};

package/src/config/platforms/advanced/product-config/AdvancedFunctionGraph.tsx

@@ -0,0 +1,65 @@
+import { CONTROL, FormConfig } from '../../../../components';
+
+export const FUNCTION_GRAPH_FORM_CONFIG: FormConfig = {
+  ui: [['requestsCount', 'memoryVolume'], 'memoryVolumeAlert', ['computationTime'], 'requestsCountAlert'],
+  controls: {
+    requestsCount: {
+      type: CONTROL.Stepper,
+      accessorKey: 'requestsCount',
+      defaultValue: 0,
+      decoratorProps: {
+        label: 'Количество запросов',
+      },
+      uiProps: {
+        min: 0,
+        max: 9_999_999_999,
+        step: 1,
+        multiplier: 1_000_000,
+        showHint: false,
+        postfix: 'млн',
+      },
+    },
+    memoryVolume: {
+      type: CONTROL.Stepper,
+      accessorKey: 'memoryVolume',
+      defaultValue: 1,
+      decoratorProps: {
+        label: 'Объем памяти',
+        labelTooltip: 'Объем выделяемый для выполнения одной функции',
+      },
+      uiProps: {
+        min: 128,
+        max: 4_194_304,
+        postfix: 'МБ',
+      },
+    },
+    memoryVolumeAlert: {
+      type: CONTROL.Alert,
+      uiProps: {
+        description: <>Первые 2&nbsp;000&nbsp;000 запросов бесплатно</>,
+      },
+      accessorKey: 'first-free',
+    },
+    computationTime: {
+      type: CONTROL.Stepper,
+      accessorKey: 'computationTime',
+      defaultValue: 0,
+      decoratorProps: {
+        label: 'Продолжительность вычислений',
+        labelTooltip: 'Максимальная продолжительность выполнения одной функции',
+      },
+      uiProps: {
+        min: 0,
+        max: 900,
+        postfix: 'сек',
+      },
+    },
+    requestsCountAlert: {
+      type: CONTROL.Alert,
+      uiProps: {
+        description: <>Продолжительность вычислений в&nbsp;размере 400&nbsp;000&nbsp;ГБ/с бесплатно</>,
+      },
+      accessorKey: 'free',
+    },
+  },
+};