ydb-embedded-ui 4.33.0 → 5.1.0

package/dist/store/reducers/storage/storage.ts

@@ -1,239 +0,0 @@
-import type {Reducer} from 'redux';
-import _ from 'lodash';
-
-import {EVersion} from '../../../types/api/storage';
-import {NodesUptimeFilterValues} from '../../../utils/nodes';
-import '../../../services/api';
-
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-
-import type {NodesApiRequestParams, NodesSortParams} from '../nodes/types';
-import type {
-    StorageAction,
-    StorageApiRequestParams,
-    StorageSortParams,
-    StorageState,
-    StorageType,
-    VisibleEntities,
-} from './types';
-import {VISIBLE_ENTITIES, STORAGE_TYPES} from './constants';
-import {prepareStorageGroupsResponse, prepareStorageNodesResponse} from './utils';
-
-export const FETCH_STORAGE = createRequestActionTypes('storage', 'FETCH_STORAGE');
-
-const SET_INITIAL = 'storage/SET_INITIAL';
-const SET_FILTER = 'storage/SET_FILTER';
-const SET_USAGE_FILTER = 'storage/SET_USAGE_FILTER';
-const SET_VISIBLE_GROUPS = 'storage/SET_VISIBLE_GROUPS';
-const SET_STORAGE_TYPE = 'storage/SET_STORAGE_TYPE';
-const SET_NODES_UPTIME_FILTER = 'storage/SET_NODES_UPTIME_FILTER';
-const SET_DATA_WAS_NOT_LOADED = 'storage/SET_DATA_WAS_NOT_LOADED';
-const SET_NODES_SORT_PARAMS = 'storage/SET_NODES_SORT_PARAMS';
-const SET_GROUPS_SORT_PARAMS = 'storage/SET_GROUPS_SORT_PARAMS';
-
-const initialState = {
-    loading: true,
-    wasLoaded: false,
-    filter: '',
-    usageFilter: [],
-    visible: VISIBLE_ENTITIES.all,
-    nodesUptimeFilter: NodesUptimeFilterValues.All,
-    type: STORAGE_TYPES.groups,
-};
-
-const storage: Reducer<StorageState, StorageAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_STORAGE.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_STORAGE.SUCCESS: {
-            return {
-                ...state,
-                nodes: action.data.nodes,
-                groups: action.data.groups,
-                total: action.data.total,
-                found: action.data.found,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_STORAGE.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-                wasLoaded: true,
-            };
-        }
-        case SET_INITIAL: {
-            return {
-                ...initialState,
-            };
-        }
-        case SET_FILTER: {
-            return {
-                ...state,
-                filter: action.data,
-            };
-        }
-        case SET_USAGE_FILTER: {
-            return {
-                ...state,
-                usageFilter: action.data,
-            };
-        }
-        case SET_VISIBLE_GROUPS: {
-            return {
-                ...state,
-                visible: action.data,
-                usageFilter: [],
-                wasLoaded: false,
-                error: undefined,
-            };
-        }
-
-        case SET_NODES_UPTIME_FILTER: {
-            return {
-                ...state,
-                nodesUptimeFilter: action.data,
-            };
-        }
-        case SET_STORAGE_TYPE: {
-            return {
-                ...state,
-                type: action.data,
-                filter: '',
-                usageFilter: [],
-                wasLoaded: false,
-                error: undefined,
-            };
-        }
-        case SET_DATA_WAS_NOT_LOADED: {
-            return {
-                ...state,
-                wasLoaded: false,
-            };
-        }
-        case SET_NODES_SORT_PARAMS: {
-            return {
-                ...state,
-                nodesSortValue: action.data.sortValue,
-                nodesSortOrder: action.data.sortOrder,
-            };
-        }
-        case SET_GROUPS_SORT_PARAMS: {
-            return {
-                ...state,
-                groupsSortValue: action.data.sortValue,
-                groupsSortOrder: action.data.sortOrder,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-const concurrentId = 'getStorageInfo';
-
-export const getStorageNodesInfo = ({
-    tenant,
-    visibleEntities,
-    ...params
-}: Omit<NodesApiRequestParams, 'type'>) => {
-    return createApiRequest({
-        request: window.api.getNodes(
-            {tenant, visibleEntities, storage: true, type: 'static', ...params},
-            {concurrentId},
-        ),
-        actions: FETCH_STORAGE,
-        dataHandler: prepareStorageNodesResponse,
-    });
-};
-
-export const getStorageGroupsInfo = ({
-    tenant,
-    visibleEntities,
-    nodeId,
-    version = EVersion.v1,
-    ...params
-}: StorageApiRequestParams) => {
-    return createApiRequest({
-        request: window.api.getStorageInfo(
-            {tenant, visibleEntities, nodeId, version, ...params},
-            {concurrentId},
-        ),
-        actions: FETCH_STORAGE,
-        dataHandler: prepareStorageGroupsResponse,
-    });
-};
-
-export function setInitialState() {
-    return {
-        type: SET_INITIAL,
-    } as const;
-}
-
-export function setStorageType(value: StorageType) {
-    return {
-        type: SET_STORAGE_TYPE,
-        data: value,
-    } as const;
-}
-
-export function setStorageTextFilter(value: string) {
-    return {
-        type: SET_FILTER,
-        data: value,
-    } as const;
-}
-
-export function setUsageFilter(value: string[]) {
-    return {
-        type: SET_USAGE_FILTER,
-        data: value,
-    } as const;
-}
-
-export function setVisibleEntities(value: VisibleEntities) {
-    return {
-        type: SET_VISIBLE_GROUPS,
-        data: value,
-    } as const;
-}
-
-export function setNodesUptimeFilter(value: NodesUptimeFilterValues) {
-    return {
-        type: SET_NODES_UPTIME_FILTER,
-        data: value,
-    } as const;
-}
-
-export const setDataWasNotLoaded = () => {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    } as const;
-};
-
-export const setNodesSortParams = (sortParams: NodesSortParams) => {
-    return {
-        type: SET_NODES_SORT_PARAMS,
-        data: sortParams,
-    } as const;
-};
-
-export const setGroupsSortParams = (sortParams: StorageSortParams) => {
-    return {
-        type: SET_GROUPS_SORT_PARAMS,
-        data: sortParams,
-    } as const;
-};
-
-export default storage;

package/dist/store/reducers/storage/types.ts

@@ -1,124 +0,0 @@
-import type {OrderType} from '@gravity-ui/react-data-table';
-
-import type {IResponseError} from '../../../types/api/error';
-import type {TSystemStateInfo} from '../../../types/api/nodes';
-import type {TPDiskStateInfo} from '../../../types/api/pdisk';
-import type {EVersion, TStorageGroupInfo} from '../../../types/api/storage';
-import type {TVDiskStateInfo} from '../../../types/api/vdisk';
-import type {ValueOf} from '../../../types/common';
-import type {NodesSortValue, NodesUptimeFilterValues} from '../../../utils/nodes';
-import type {StorageSortValue} from '../../../utils/storage';
-import type {ApiRequestAction} from '../../utils';
-
-import {STORAGE_TYPES, VISIBLE_ENTITIES} from './constants';
-import {
-    FETCH_STORAGE,
-    setDataWasNotLoaded,
-    setGroupsSortParams,
-    setInitialState,
-    setNodesSortParams,
-    setNodesUptimeFilter,
-    setStorageTextFilter,
-    setStorageType,
-    setUsageFilter,
-    setVisibleEntities,
-} from './storage';
-
-export type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
-export type StorageType = ValueOf<typeof STORAGE_TYPES>;
-
-export interface PreparedStorageNode extends TSystemStateInfo {
-    NodeId: number;
-    PDisks: TPDiskStateInfo[] | undefined;
-    VDisks: TVDiskStateInfo[] | undefined;
-
-    Missing: number;
-    Uptime: string;
-}
-
-export interface PreparedStorageGroup extends TStorageGroupInfo {
-    PoolName: string | undefined;
-
-    Usage: number;
-    Read: number;
-    Write: number;
-    Used: number;
-    Limit: number;
-    Degraded: number;
-    Kind: string | undefined;
-
-    UsedSpaceFlag: number;
-}
-
-export interface UsageFilter {
-    threshold: number;
-    count: number;
-}
-
-export interface StorageSortParams {
-    sortOrder?: OrderType;
-    sortValue?: StorageSortValue;
-}
-
-export interface StorageSortAndFilterParams extends StorageSortParams {
-    filter?: string; // PoolName or GroupId
-
-    offset?: number;
-    limit?: number;
-}
-
-export interface StorageApiRequestParams extends StorageSortAndFilterParams {
-    tenant?: string;
-    nodeId?: string;
-    visibleEntities?: VisibleEntities;
-
-    version?: EVersion;
-}
-
-export interface StorageState {
-    loading: boolean;
-    wasLoaded: boolean;
-    filter: string;
-    usageFilter: string[];
-    visible: VisibleEntities;
-    nodesUptimeFilter: NodesUptimeFilterValues;
-    groupsSortValue?: StorageSortValue;
-    groupsSortOrder?: OrderType;
-    nodesSortValue?: NodesSortValue;
-    nodesSortOrder?: OrderType;
-    type: StorageType;
-    nodes?: PreparedStorageNode[];
-    groups?: PreparedStorageGroup[];
-    found?: number;
-    total?: number;
-    error?: IResponseError;
-}
-
-export interface PreparedStorageResponse {
-    nodes?: PreparedStorageNode[];
-    groups?: PreparedStorageGroup[];
-    found: number | undefined;
-    total: number | undefined;
-}
-
-type GetStorageInfoApiRequestAction = ApiRequestAction<
-    typeof FETCH_STORAGE,
-    PreparedStorageResponse,
-    IResponseError
->;
-
-export type StorageAction =
-    | GetStorageInfoApiRequestAction
-    | ReturnType<typeof setInitialState>
-    | ReturnType<typeof setStorageType>
-    | ReturnType<typeof setStorageTextFilter>
-    | ReturnType<typeof setUsageFilter>
-    | ReturnType<typeof setVisibleEntities>
-    | ReturnType<typeof setNodesUptimeFilter>
-    | ReturnType<typeof setDataWasNotLoaded>
-    | ReturnType<typeof setNodesSortParams>
-    | ReturnType<typeof setGroupsSortParams>;
-
-export interface StorageStateSlice {
-    storage: StorageState;
-}

package/dist/store/reducers/storage/utils.ts

@@ -1,216 +0,0 @@
-import type {TNodeInfo, TNodesInfo} from '../../../types/api/nodes';
-import type {
-    TStorageGroupInfo,
-    TStorageGroupInfoV2,
-    TStorageInfo,
-    TStoragePoolInfo,
-} from '../../../types/api/storage';
-import {EVDiskState, type TVDiskStateInfo} from '../../../types/api/vdisk';
-import {TPDiskState} from '../../../types/api/pdisk';
-import {EFlag} from '../../../types/api/enums';
-import {getPDiskType} from '../../../utils/pdisk';
-import {getUsage} from '../../../utils/storage';
-import {calcUptime} from '../../../utils/dataFormatters/dataFormatters';
-
-import type {PreparedStorageGroup, PreparedStorageNode, PreparedStorageResponse} from './types';
-
-// ==== Constants  ====
-
-const FLAGS_POINTS = {
-    [EFlag.Green]: 1,
-    [EFlag.Yellow]: 100,
-    [EFlag.Orange]: 10_000,
-    [EFlag.Red]: 1_000_000,
-};
-
-// ==== Prepare groups ====
-
-const prepareVDisk = (vDisk: TVDiskStateInfo, poolName: string | undefined) => {
-    // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
-    return {
-        ...vDisk,
-        StoragePoolName: poolName,
-        Donors: vDisk.Donors?.map((donor) => ({
-            ...donor,
-            StoragePoolName: poolName,
-        })),
-    };
-};
-
-const prepareStorageGroupData = (
-    group: TStorageGroupInfo,
-    poolName?: string,
-): PreparedStorageGroup => {
-    let missing = 0;
-    let usedSpaceFlag = 0;
-    let usedSpaceBytes = 0;
-    let limitSizeBytes = 0;
-    let readSpeedBytesPerSec = 0;
-    let writeSpeedBytesPerSec = 0;
-    let mediaType = '';
-
-    if (group.VDisks) {
-        for (const vDisk of group.VDisks) {
-            const {
-                Replicated,
-                VDiskState,
-                AvailableSize,
-                AllocatedSize,
-                PDisk,
-                DiskSpace,
-                ReadThroughput,
-                WriteThroughput,
-            } = vDisk;
-
-            if (
-                !Replicated ||
-                PDisk?.State !== TPDiskState.Normal ||
-                VDiskState !== EVDiskState.OK
-            ) {
-                missing += 1;
-            }
-
-            if (DiskSpace && DiskSpace !== EFlag.Grey) {
-                usedSpaceFlag += FLAGS_POINTS[DiskSpace];
-            }
-
-            const available = Number(AvailableSize ?? PDisk?.AvailableSize) || 0;
-            const allocated = Number(AllocatedSize) || 0;
-
-            usedSpaceBytes += allocated;
-            limitSizeBytes += available + allocated;
-
-            readSpeedBytesPerSec += Number(ReadThroughput) || 0;
-            writeSpeedBytesPerSec += Number(WriteThroughput) || 0;
-
-            const currentType = getPDiskType(PDisk || {});
-            mediaType =
-                currentType && (currentType === mediaType || mediaType === '')
-                    ? currentType
-                    : 'Mixed';
-        }
-    }
-
-    const vDisks = group.VDisks?.map((vdisk) => prepareVDisk(vdisk, poolName));
-    const usage = getUsage({Used: usedSpaceBytes, Limit: limitSizeBytes}, 5);
-
-    return {
-        ...group,
-        VDisks: vDisks,
-        Usage: usage,
-        Read: readSpeedBytesPerSec,
-        Write: writeSpeedBytesPerSec,
-        PoolName: poolName,
-        Used: usedSpaceBytes,
-        Limit: limitSizeBytes,
-        Degraded: missing,
-        UsedSpaceFlag: usedSpaceFlag,
-        Kind: mediaType || undefined,
-    };
-};
-
-const prepareStorageGroupDataV2 = (group: TStorageGroupInfoV2): PreparedStorageGroup => {
-    const {
-        VDisks = [],
-        PoolName,
-        Usage = 0,
-        Read = 0,
-        Write = 0,
-        Used = 0,
-        Limit = 0,
-        Degraded = 0,
-        Kind,
-    } = group;
-
-    const UsedSpaceFlag = VDisks.reduce((acc, {DiskSpace}) => {
-        if (DiskSpace && DiskSpace !== EFlag.Grey) {
-            return acc + FLAGS_POINTS[DiskSpace];
-        }
-        return acc;
-    }, 0);
-
-    const vDisks = VDisks.map((vdisk) => prepareVDisk(vdisk, PoolName));
-    const usage = Math.floor(Number(Usage) * 100);
-
-    return {
-        ...group,
-        UsedSpaceFlag,
-        PoolName,
-        Kind,
-        VDisks: vDisks,
-        Usage: usage,
-        Read: Number(Read),
-        Write: Number(Write),
-        Used: Number(Used),
-        Limit: Number(Limit),
-        Degraded: Number(Degraded),
-    };
-};
-
-export const prepareStorageGroups = (
-    StorageGroups?: TStorageGroupInfoV2[],
-    StoragePools?: TStoragePoolInfo[],
-) => {
-    let preparedGroups: PreparedStorageGroup[] = [];
-    if (StorageGroups) {
-        preparedGroups = StorageGroups.map(prepareStorageGroupDataV2);
-    } else {
-        StoragePools?.forEach((pool) => {
-            pool.Groups?.forEach((group) => {
-                preparedGroups.push(prepareStorageGroupData(group, pool.Name));
-            });
-        });
-    }
-
-    return preparedGroups;
-};
-
-// ==== Prepare nodes ====
-
-const prepareStorageNodeData = (node: TNodeInfo): PreparedStorageNode => {
-    const systemState = node.SystemState ?? {};
-    const missing =
-        node.PDisks?.filter((pDisk) => {
-            return pDisk.State !== TPDiskState.Normal;
-        }).length || 0;
-
-    return {
-        NodeId: node.NodeId,
-        SystemState: systemState.SystemState,
-        DataCenter: systemState.DataCenter,
-        Rack: systemState.Rack,
-        Host: systemState.Host,
-        Endpoints: systemState.Endpoints,
-        Uptime: calcUptime(systemState.StartTime),
-        StartTime: systemState.StartTime,
-        PDisks: node.PDisks,
-        VDisks: node.VDisks,
-        Missing: missing,
-    };
-};
-
-// ==== Prepare responses ====
-
-export const prepareStorageNodesResponse = (data: TNodesInfo): PreparedStorageResponse => {
-    const {Nodes, TotalNodes, FoundNodes} = data;
-
-    const preparedNodes = Nodes?.map(prepareStorageNodeData);
-
-    return {
-        nodes: preparedNodes,
-        total: Number(TotalNodes) || preparedNodes?.length,
-        found: Number(FoundNodes),
-    };
-};
-
-export const prepareStorageGroupsResponse = (data: TStorageInfo): PreparedStorageResponse => {
-    const {StoragePools, StorageGroups, TotalGroups, FoundGroups} = data;
-
-    const preparedGroups = prepareStorageGroups(StorageGroups, StoragePools);
-
-    return {
-        groups: preparedGroups,
-        total: Number(TotalGroups) || preparedGroups.length,
-        found: Number(FoundGroups),
-    };
-};