@cloud-ru/uikit-product-calculator 0.33.3

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

@@ -0,0 +1,134 @@
+import { CONTROL, FormConfig } from '../../../../components';
+import { generateCpuItems, getObs } from '../../../utils';
+
+const resourceUsageModeItem = {
+  Dedicated: 'dedicated',
+  NonDedicated: 'nonDedicated',
+};
+
+const requestQueueTypeItem = {
+  Sql: 'sql',
+  GeneralPurpose: 'general-purpose',
+};
+
+export const DATA_LAKE_INSIGHT_FORM_CONFIG: FormConfig = {
+  ui: ['requestQueueType', ['resourceUsageMode', 'queryRunTime'], ['computeUnitCount'], ['obs', 'scannedDataVolume']],
+  controls: {
+    requestQueueType: {
+      type: CONTROL.Carousel,
+      accessorKey: 'requestQueueType',
+      defaultValue: requestQueueTypeItem.Sql,
+      items: [
+        {
+          value: requestQueueTypeItem.Sql,
+          label: 'For SQL',
+          description:
+            'Используется стандартный SQL, Spark и Presto SQL для запроса и анализа разнородных данных из нескольких облачных служб. Задания SQL поддерживают основные форматы данных, такие как CSV, JSON, Parquet, Carbon и ORC',
+        },
+        {
+          value: requestQueueTypeItem.GeneralPurpose,
+          label: 'For General Purpose',
+          description:
+            'Включает в себя Задания Spark и Flink. Spark предназначен для создания сеансов и заданий пакетной обработки через консоль управления. Flink предназначен для анализа потоков в реальном времени с помощью инструкций или загруженных файлов.',
+        },
+      ],
+      decoratorProps: {
+        label: 'Тип очереди запроса',
+      },
+      uiProps: {
+        showItems: 2,
+        pagination: false,
+        arrows: false,
+      },
+    },
+    resourceUsageMode: {
+      type: CONTROL.Segmented,
+      accessorKey: 'resourceUsageMode',
+      defaultValue: resourceUsageModeItem.Dedicated,
+      items: [
+        {
+          value: resourceUsageModeItem.Dedicated,
+          label: 'Выделенный',
+        },
+        {
+          value: resourceUsageModeItem.NonDedicated,
+          label: 'Невыделенный',
+        },
+      ],
+      decoratorProps: {
+        label: 'Режим использования ресурса',
+      },
+    },
+    queryRunTime: {
+      type: CONTROL.Stepper,
+      accessorKey: 'queryRunTime',
+      defaultValue: 0,
+      decoratorProps: {
+        label: 'Время использования ресурса',
+      },
+      uiProps: {
+        min: 0,
+        max: 10_000,
+        postfix: 'ч',
+        showHint: false,
+        visible: false,
+      },
+      watchedControls: { resourceUsageMode: 'resourceUsageMode' },
+      relateFn: ({ resourceUsageMode }) => {
+        if (resourceUsageModeItem.NonDedicated === resourceUsageMode) {
+          return {
+            uiProps: {
+              visible: true,
+            },
+          };
+        }
+      },
+    },
+    computeUnitCount: {
+      type: CONTROL.Segmented,
+      accessorKey: 'computeUnitCount',
+      items: generateCpuItems([16, 64, 256, 512]),
+      defaultValue: '16',
+      decoratorProps: {
+        label: 'Количество CU',
+        labelTooltip: 'CU (Compute unit) — единица тарификации, которая состоит из 1 vCPU и 4 ГБ памяти.',
+      },
+    },
+    scannedDataVolume: {
+      type: CONTROL.Stepper,
+      accessorKey: 'scannedDataVolume',
+      decoratorProps: {
+        label: 'Объем сканируемых данных',
+      },
+      uiProps: {
+        min: 0,
+        max: 9_999_999_999,
+        postfix: 'ГБ',
+        showHint: false,
+        visible: false,
+      },
+      watchedControls: { requestQueueType: 'requestQueueType' },
+      relateFn: ({ requestQueueType }) => {
+        if (requestQueueTypeItem.Sql === requestQueueType) {
+          return {
+            uiProps: {
+              visible: true,
+            },
+          };
+        }
+      },
+    },
+    obs: getObs({
+      space: {
+        accessorKey: 'obs.space',
+        defaultValue: 0,
+        uiProps: {
+          min: 0,
+        },
+      },
+      units: {
+        accessorKey: 'obs.unitsOfCalculation',
+      },
+    }),
+  },
+};

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

@@ -0,0 +1,94 @@
+import { CONTROL, FormConfig } from '../../../../components';
+import { generateInstanceConfigItems, getDisk, getObs } from '../../../utils';
+
+const nodeValueItems = generateInstanceConfigItems([
+  [4, 32],
+  [8, 64],
+  [32, 256],
+  [64, 512],
+]);
+
+export const DATA_WAREHOUSE_SERVICE_FORM_CONFIG: FormConfig = {
+  ui: [
+    ['nodeValue', 'nodeCount'],
+    ['evs', 'obs'],
+  ],
+  controls: {
+    nodeValue: {
+      type: CONTROL.SelectSingle,
+      accessorKey: 'node.value',
+      defaultValue: nodeValueItems[0].value,
+      items: nodeValueItems,
+      decoratorProps: {
+        label: 'Конфигурация узла',
+      },
+    },
+    nodeCount: {
+      type: CONTROL.Stepper,
+      accessorKey: 'node.count',
+      defaultValue: 3,
+      decoratorProps: {
+        label: 'Количество узлов (нод)',
+      },
+      uiProps: {
+        min: 3,
+        max: 256,
+        postfix: 'Шт',
+      },
+    },
+    evs: getDisk({
+      space: {
+        accessorKey: 'evs.systemDisk.diskSpace',
+        defaultValue: 20,
+        label: 'Горячее хранилище',
+        decoratorProps: {
+          labelTooltip: 'Хранилище на базе сервиса EVS',
+        },
+        uiProps: {
+          min: 20,
+          max: 2_000,
+        },
+        watchedControls: { nodeValue: 'node.value' },
+        relateFn: ({ nodeValue }) => {
+          if (nodeValue === nodeValueItems[1].value) {
+            return {
+              uiProps: {
+                min: 100,
+                max: 4_000,
+              },
+            };
+          }
+          if (nodeValue === nodeValueItems[2].value) {
+            return {
+              uiProps: {
+                min: 100,
+                max: 16_000,
+              },
+            };
+          }
+          if (nodeValue === nodeValueItems[3].value) {
+            return {
+              uiProps: {
+                min: 100,
+                max: 32_000,
+              },
+            };
+          }
+        },
+      },
+      specification: {
+        accessorKey: 'evs.systemDisk.specification',
+        defaultValue: 'SSD',
+        uiProps: {
+          disabled: true,
+        },
+      },
+    }),
+    obs: getObs({
+      space: {
+        defaultValue: 1,
+      },
+      units: {},
+    }),
+  },
+};

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

@@ -0,0 +1,69 @@
+import { CONTROL, FormConfig } from '../../../../components';
+import { generateRamItems, getObs } from '../../../utils';
+
+export const DSC_MEMCACHED_FORM_CONFIG: FormConfig = {
+  ui: ['instanceType', ['cacheSize', 'instancesCount'], 'alert', ['obs']],
+  controls: {
+    instanceType: {
+      type: CONTROL.Carousel,
+      defaultValue: 'Master/Standby',
+      accessorKey: 'instanceType',
+      items: [
+        {
+          value: 'Master/Standby',
+          label: 'Master/Standby',
+          description:
+            'Каждый экземпляр работает на двух узлах кэша - один главный (для чтения/записи данных) и один резервный (реплицирует данныев режиме реального времени и берет на себя управление в случае сбоя основного кэш-узла)',
+        },
+        {
+          value: 'Single-Node',
+          label: 'Single-Node',
+          description:
+            'Каждый экземпляр работает только на одном узле кэша. В основном используются для временного хранения данных и не подходят для сценариев обслуживания с высокой надежностью, поддерживают интенсивные параллельные операции чтения/записи, но не обеспечивают сохранение данных',
+        },
+      ],
+      decoratorProps: {
+        label: 'Тип инстанса',
+      },
+    },
+    cacheSize: {
+      type: CONTROL.Segmented,
+      accessorKey: 'cacheSize',
+      defaultValue: '2',
+      items: generateRamItems([2, 4, 8, 16, 32, 64]),
+      decoratorProps: {
+        label: 'Объем кэша',
+        labelTooltip:
+          'Брокер — это приложение, которое преобразует сообщения и выступает посредником между другими приложениями',
+      },
+    },
+    instancesCount: {
+      type: CONTROL.Stepper,
+      accessorKey: 'instancesCount',
+      defaultValue: 1,
+      decoratorProps: {
+        label: 'Количество инстансов',
+      },
+      uiProps: {
+        min: 1,
+        max: 100,
+        postfix: 'Шт',
+      },
+    },
+    alert: {
+      type: CONTROL.Alert,
+      uiProps: {
+        description: 'Хранилище используется под бэкапы. Рекомендуем указывать объем не меньше объема кэша',
+      },
+      accessorKey: 'backup',
+    },
+    obs: getObs({
+      space: {
+        accessorKey: 'obs.space',
+      },
+      units: {
+        accessorKey: 'obs.unitsOfCalculation',
+      },
+    }),
+  },
+};

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

@@ -0,0 +1,220 @@
+import { CONTROL, FormConfig } from '../../../../components';
+import { generateCpuItems, generateRamItems, getObs } from '../../../utils';
+
+const RedisVersionItem = {
+  Redis3: '3',
+  Redis4: '4',
+  Redis5: '5',
+  Redis6: '6',
+};
+
+const versionItems = [
+  {
+    value: RedisVersionItem.Redis3,
+    label: 'Redis 3.0',
+  },
+  {
+    value: RedisVersionItem.Redis4,
+    label: 'Redis 4.0',
+  },
+  {
+    value: RedisVersionItem.Redis5,
+    label: 'Redis 5.0',
+  },
+  {
+    value: RedisVersionItem.Redis6,
+    label: 'Redis 6.0',
+  },
+];
+
+const InstanceTypeItem = {
+  MasterStandby: 'Master/Standby',
+  SingleNode: 'Single-Node',
+  ProxyCluster: 'Proxy Cluster',
+  RedisCluster: 'Redis Cluster',
+};
+
+const instanceTypeItemMasterStandby = {
+  value: InstanceTypeItem.MasterStandby,
+  label: 'Master/Standby',
+  description:
+    'Каждый экземпляр работает на двух узлах кэша - один главный (для чтения/записи данных) и один резервный (реплицирует данныев режиме реального времени и берет на себя управление в случае сбоя основного кэш-узла',
+};
+
+const instanceTypeItemSingleNode = {
+  value: InstanceTypeItem.SingleNode,
+  label: 'Single-Node',
+  description:
+    'Каждый экземпляр работает только на одном узле кэша. В основном используются для временного хранения данных и не подходят для сценариев обслуживания с высокой надежностью, поддерживают интенсивные параллельные операции чтения/записи, но не обеспечивают сохранение данных',
+};
+
+const instanceTypeItemProxyCluster = {
+  value: InstanceTypeItem.ProxyCluster,
+  label: 'Proxy Cluster',
+  description: 'Используется так же, как экземпляр с одним узлом. Приложения получают доступ к Redis через прокси',
+};
+
+const instanceTypeItemRedisCluster = {
+  value: InstanceTypeItem.RedisCluster,
+  label: 'Redis Cluster',
+  description: 'Нативная распределенная реализация Redis. Приложения подключаются через клиентов Redis Cluster',
+};
+
+const versionToInstanceTypeMap = {
+  [RedisVersionItem.Redis3]: [instanceTypeItemMasterStandby, instanceTypeItemSingleNode, instanceTypeItemProxyCluster],
+  [RedisVersionItem.Redis4]: [instanceTypeItemMasterStandby, instanceTypeItemSingleNode, instanceTypeItemRedisCluster],
+  [RedisVersionItem.Redis5]: [instanceTypeItemMasterStandby, instanceTypeItemSingleNode, instanceTypeItemRedisCluster],
+  [RedisVersionItem.Redis6]: [instanceTypeItemMasterStandby, instanceTypeItemSingleNode],
+};
+
+const versionInstanceTypeToCacheSizeMap = {
+  [RedisVersionItem.Redis3]: {
+    [InstanceTypeItem.MasterStandby]: [2, 4, 8, 16, 32, 64],
+    [InstanceTypeItem.SingleNode]: [2, 4, 8, 16, 32, 64],
+    [InstanceTypeItem.ProxyCluster]: [64, 128, 256],
+  },
+  [RedisVersionItem.Redis4]: {
+    [InstanceTypeItem.MasterStandby]: [1, 2, 4, 8, 16, 24, 32, 48, 64],
+    [InstanceTypeItem.SingleNode]: [1, 2, 4, 8, 16, 24, 32, 48, 64],
+    [InstanceTypeItem.RedisCluster]: [4, 8, 16, 32, 64, 128, 256],
+  },
+  [RedisVersionItem.Redis5]: {
+    [InstanceTypeItem.MasterStandby]: [1, 2, 4, 8, 16, 24, 32, 48, 64],
+    [InstanceTypeItem.SingleNode]: [1, 2, 4, 8, 16, 24, 32, 48, 64],
+    [InstanceTypeItem.RedisCluster]: [4, 8, 16, 32, 64, 128, 256],
+  },
+  [RedisVersionItem.Redis6]: {
+    [InstanceTypeItem.MasterStandby]: [1, 2, 4, 8, 16, 24, 32, 48, 64],
+    [InstanceTypeItem.SingleNode]: [1, 2, 4, 8, 16, 24, 32, 48, 64],
+  },
+};
+
+const versionInstanceTypeToReplicasCountMap = {
+  [RedisVersionItem.Redis3]: {
+    [InstanceTypeItem.MasterStandby]: [],
+    [InstanceTypeItem.SingleNode]: [],
+    [InstanceTypeItem.ProxyCluster]: [],
+  },
+  [RedisVersionItem.Redis4]: {
+    [InstanceTypeItem.MasterStandby]: [2, 3, 4, 5],
+    [InstanceTypeItem.SingleNode]: [],
+    [InstanceTypeItem.RedisCluster]: [1, 2, 3, 4, 5],
+  },
+  [RedisVersionItem.Redis5]: {
+    [InstanceTypeItem.MasterStandby]: [2, 3, 4, 5],
+    [InstanceTypeItem.SingleNode]: [],
+    [InstanceTypeItem.RedisCluster]: [1, 2, 3, 4, 5],
+  },
+  [RedisVersionItem.Redis6]: {
+    [InstanceTypeItem.MasterStandby]: [2],
+    [InstanceTypeItem.SingleNode]: [],
+  },
+};
+
+const cacheSizeItems = generateRamItems([2, 4, 8, 16, 32, 64]);
+
+export const DCS_REDIS_FORM_CONFIG: FormConfig = {
+  ui: [['version'], 'instanceType', ['cacheSize', 'instancesCount'], 'obsAlert', ['replicasCount'], ['obs']],
+  controls: {
+    version: {
+      type: CONTROL.SelectSingle,
+      accessorKey: 'version',
+      defaultValue: RedisVersionItem.Redis3,
+      items: versionItems,
+      decoratorProps: {
+        label: 'Версия',
+        labelTooltip: `Экземпляры Redis версии 3.0 разворачиваются на виртуальных машинах за несколько минут, а версии 4.0, 5.0 и 6.0 — в контейнерах за несколько секунд.`,
+      },
+    },
+    instanceType: {
+      type: CONTROL.Carousel,
+      accessorKey: 'instanceType',
+      items: [...versionToInstanceTypeMap[RedisVersionItem.Redis3]],
+      defaultValue: InstanceTypeItem.MasterStandby,
+      decoratorProps: { label: 'Тип инстанса' },
+      watchedControls: { version: 'version' },
+      relateFn: ({ version }) => ({ items: versionToInstanceTypeMap[version] }),
+    },
+    cacheSize: {
+      type: CONTROL.Segmented,
+      accessorKey: 'cacheSize',
+      defaultValue: cacheSizeItems[0].value,
+      items: cacheSizeItems,
+      decoratorProps: {
+        label: 'Объем кэша',
+        labelTooltip:
+          'Брокер — это приложение, которое преобразует сообщения и выступает посредником между другими приложениями',
+      },
+      watchedControls: { version: 'version', instanceType: 'instanceType' },
+      relateFn: ({ version, instanceType }) => {
+        const items = versionInstanceTypeToCacheSizeMap[version][instanceType] || [];
+
+        return {
+          items: generateRamItems(items),
+        };
+      },
+    },
+    instancesCount: {
+      type: CONTROL.Stepper,
+      decoratorProps: {
+        label: 'Количество инстансов',
+      },
+      accessorKey: 'instancesCount',
+      defaultValue: 1,
+      uiProps: {
+        min: 1,
+        max: 100,
+        postfix: 'Шт',
+      },
+    },
+    obsAlert: {
+      type: CONTROL.Alert,
+      uiProps: {
+        description: 'Хранилище используется под бэкапы. Рекомендуем указывать объем не меньше объема кэша',
+      },
+      accessorKey: 'backup',
+    },
+    replicasCount: {
+      type: CONTROL.Segmented,
+      accessorKey: 'replicasCount',
+      defaultValue: '1',
+      items: generateCpuItems([1, 2, 3, 4, 5]),
+      decoratorProps: {
+        label: 'Количество реплик',
+      },
+      watchedControls: { version: 'version', instanceType: 'instanceType' },
+      relateFn: ({ version, instanceType }) => {
+        const items = versionInstanceTypeToReplicasCountMap?.[version]?.[instanceType];
+
+        if (items?.length > 0) {
+          return {
+            items: generateCpuItems(items),
+            uiProps: {
+              visible: true,
+            },
+          };
+        }
+
+        return {
+          uiProps: {
+            visible: false,
+          },
+        };
+      },
+    },
+
+    obs: getObs({
+      space: {
+        accessorKey: 'obs.space',
+        defaultValue: 0,
+        uiProps: {
+          min: 0,
+          max: 9_999_999_900,
+        },
+      },
+      units: {
+        accessorKey: 'obs.unitsOfCalculation',
+      },
+    }),
+  },
+};

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

@@ -0,0 +1,186 @@
+import { CONTROL, FormConfig } from '../../../../components';
+import { formatNumber } from '../../../../utils';
+import { getDisk } from '../../../utils';
+
+enum ConfigTypeItem {
+  Kafka2_4 = 'kafka.2u4g.cluster',
+  Kafka4_8 = 'kafka.4u8g.cluster',
+  Kafka8_16 = 'kafka.8u16g.cluster',
+  Kafka12_24 = 'kafka.12u24g.cluster',
+  Kafka16_32 = 'kafka.16u32g.cluster',
+}
+
+const configItems = {
+  [ConfigTypeItem.Kafka2_4]: {
+    parts: '7',
+    partition: '250',
+    tps: '30000',
+    throughput: '100',
+    usersConnectionsCount: '2000',
+    usersGroupCount: '20',
+  },
+
+  [ConfigTypeItem.Kafka4_8]: {
+    parts: '14',
+    partition: '500',
+    tps: '100000',
+    throughput: '200',
+    usersConnectionsCount: '4000',
+    usersGroupCount: '100',
+  },
+
+  [ConfigTypeItem.Kafka8_16]: {
+    parts: '27',
+    partition: '1000',
+    tps: '150000',
+    throughput: '375',
+    usersConnectionsCount: '4000',
+    usersGroupCount: '150',
+  },
+
+  [ConfigTypeItem.Kafka12_24]: {
+    parts: '41',
+    partition: '1500',
+    tps: '200000',
+    throughput: '625',
+    usersConnectionsCount: '4000',
+    usersGroupCount: '200',
+  },
+
+  [ConfigTypeItem.Kafka16_32]: {
+    parts: '50',
+    partition: '2000',
+    tps: '250000',
+    throughput: '750',
+    usersConnectionsCount: '4000',
+    usersGroupCount: '200',
+  },
+};
+
+type Item = {
+  parts: string;
+  partition: string;
+  tps: string;
+  throughput: string;
+  usersConnectionsCount: string;
+  usersGroupCount: string;
+};
+
+function getDescription(configType: ConfigTypeItem) {
+  const rows: Item = configItems[configType];
+  const { parts, partition, tps, throughput, usersConnectionsCount, usersGroupCount } = rows;
+  return (
+    <>
+      {formatNumber(Number(parts))} частей ядра виртуального процессора <br />
+      {formatNumber(Number(partition))} партиций <br />
+      {formatNumber(Number(tps))} TPS <br />
+      {formatNumber(Number(throughput))} МБ/с пропускная способность <br />
+      {formatNumber(Number(usersConnectionsCount))} пользовательский подключений <br />
+      {formatNumber(Number(usersGroupCount))} пользовательских групп <br />
+    </>
+  ) as unknown as string;
+}
+
+const configTypeItems = [
+  {
+    value: ConfigTypeItem.Kafka2_4,
+    label: `Флейвор ${ConfigTypeItem.Kafka2_4}`,
+    description: getDescription(ConfigTypeItem.Kafka2_4),
+  },
+  {
+    value: ConfigTypeItem.Kafka4_8,
+    label: `Флейвор ${ConfigTypeItem.Kafka4_8}`,
+    description: getDescription(ConfigTypeItem.Kafka4_8),
+  },
+  {
+    value: ConfigTypeItem.Kafka8_16,
+    label: `Флейвор ${ConfigTypeItem.Kafka8_16}`,
+    description: getDescription(ConfigTypeItem.Kafka8_16),
+  },
+  {
+    value: ConfigTypeItem.Kafka12_24,
+    label: `Флейвор ${ConfigTypeItem.Kafka12_24}`,
+    description: getDescription(ConfigTypeItem.Kafka12_24),
+  },
+  {
+    value: ConfigTypeItem.Kafka16_32,
+    label: `Флейвор ${ConfigTypeItem.Kafka16_32}`,
+    description: getDescription(ConfigTypeItem.Kafka16_32),
+  },
+];
+
+export const DMS_KAFKA_FORM_CONFIG: FormConfig = {
+  ui: ['configType', ['evs'], ['brokersCount']],
+  controls: {
+    configType: {
+      type: CONTROL.ToggleCards,
+      accessorKey: 'config.type',
+      defaultValue: ConfigTypeItem.Kafka2_4,
+      items: configTypeItems,
+      decoratorProps: {
+        label: 'Тип конфигурации',
+        labelTooltip: 'Данные конфигурации на 1 брокер в кластере',
+      },
+      onChangeFn: (value: ConfigTypeItem, setValue) => {
+        setValue([['config', { ...configItems[value], type: value }]]);
+      },
+    },
+    evs: getDisk({
+      space: {
+        accessorKey: 'evs.systemDisk.diskSpace',
+        defaultValue: 100,
+        decoratorProps: {
+          label: 'Объем системного диска',
+          labelTooltip: (
+            <>
+              Объем хранилища на 1 брокер в кластере
+              <br />
+              Рекомендуем указывать объем хранилища исходя из ожидаемого размера сообщений и количества реплик.
+              Например, если предполагаемый размер сообщения — 100 ГБ, то объем дискового пространства должен быть не
+              менее: 100 ГБ x количество реплик + 100 ГБ (резервное пространство).
+            </>
+          ),
+        },
+        uiProps: {
+          min: 100,
+          max: 30000,
+          showHint: true,
+        },
+      },
+      specification: {
+        accessorKey: 'evs.systemDisk.specification',
+        defaultValue: 'SSD',
+      },
+    }),
+    brokersCount: {
+      type: CONTROL.Stepper,
+      decoratorProps: {
+        label: 'Количество брокеров',
+      },
+      accessorKey: 'brokersCount',
+      defaultValue: 3,
+      uiProps: {
+        min: 3,
+        max: 50,
+        postfix: 'шт',
+      },
+    },
+    // set-default value
+    config: {
+      type: CONTROL.Segmented,
+      accessorKey: 'config',
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      defaultValue: configItems[ConfigTypeItem.Kafka2_4],
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      items: [configItems[ConfigTypeItem.Kafka2_4]],
+      decoratorProps: {
+        label: '',
+      },
+      uiProps: {
+        visible: false,
+      },
+    },
+  },
+};