ydb-embedded-ui 4.33.0 → 5.1.0

package/dist/store/reducers/cluster/__test__/parseGroupsStatsQueryResponse.test.ts

@@ -1,121 +0,0 @@
-import {parseGroupsStatsQueryResponse} from '../utils';
-
-describe('parseGroupsStatsQueryResponse', () => {
-    const columns = [
-        {
-            name: 'PDiskFilter',
-            type: 'Utf8?',
-        },
-        {
-            name: 'ErasureSpecies',
-            type: 'Utf8?',
-        },
-        {
-            name: 'CurrentAvailableSize',
-            type: 'Uint64?',
-        },
-        {
-            name: 'CurrentAllocatedSize',
-            type: 'Uint64?',
-        },
-        {
-            name: 'CurrentGroupsCreated',
-            type: 'Uint32?',
-        },
-        {
-            name: 'AvailableGroupsToCreate',
-            type: 'Uint32?',
-        },
-    ];
-
-    // 2 disk types and 2 erasure types
-    const dataSet1 = {
-        columns,
-        result: [
-            ['Type:SSD', 'block-4-2', '1000', '2000', 100, 50],
-            ['Type:ROT', 'block-4-2', '2000', '1000', 50, 0],
-            ['Type:ROT', 'mirror-3of4', '1000', '0', 15, 0],
-            ['Type:SSD', 'mirror-3of4', '1000', '0', 5, 50],
-            ['Type:ROT', 'mirror-3-dc', null, null, null, 0],
-            ['Type:SSD', 'mirror-3-dc', null, null, null, 0],
-        ],
-    };
-
-    // 2 disk types and 1 erasure types, but with additional disks params
-    const dataSet2 = {
-        columns,
-        result: [
-            ['Type:ROT,SharedWithOs:0,ReadCentric:0,Kind:0', 'mirror-3-dc', '1000', '500', 16, 16],
-            ['Type:ROT,SharedWithOs:1,ReadCentric:0,Kind:0', 'mirror-3-dc', '2000', '1000', 8, 24],
-            ['Type:SSD', 'mirror-3-dc', '3000', '400', 2, 10],
-            ['Type:ROT', 'mirror-3-dc', null, null, null, 32],
-            ['Type:ROT', 'block-4-2', null, null, null, 20],
-            ['Type:SSD', 'block-4-2', null, null, null, 0],
-        ],
-    };
-    const parsedDataSet1 = {
-        SSD: {
-            'block-4-2': {
-                diskType: 'SSD',
-                erasure: 'block-4-2',
-                createdGroups: 100,
-                totalGroups: 150,
-                allocatedSize: 2000,
-                availableSize: 1000,
-            },
-            'mirror-3of4': {
-                diskType: 'SSD',
-                erasure: 'mirror-3of4',
-                createdGroups: 5,
-                totalGroups: 55,
-                allocatedSize: 0,
-                availableSize: 1000,
-            },
-        },
-        HDD: {
-            'block-4-2': {
-                diskType: 'HDD',
-                erasure: 'block-4-2',
-                createdGroups: 50,
-                totalGroups: 50,
-                allocatedSize: 1000,
-                availableSize: 2000,
-            },
-            'mirror-3of4': {
-                diskType: 'HDD',
-                erasure: 'mirror-3of4',
-                createdGroups: 15,
-                totalGroups: 15,
-                allocatedSize: 0,
-                availableSize: 1000,
-            },
-        },
-    };
-
-    const parsedDataSet2 = {
-        HDD: {
-            'mirror-3-dc': {
-                diskType: 'HDD',
-                erasure: 'mirror-3-dc',
-                createdGroups: 24,
-                totalGroups: 64,
-                allocatedSize: 1500,
-                availableSize: 3000,
-            },
-        },
-        SSD: {
-            'mirror-3-dc': {
-                diskType: 'SSD',
-                erasure: 'mirror-3-dc',
-                createdGroups: 2,
-                totalGroups: 12,
-                allocatedSize: 400,
-                availableSize: 3000,
-            },
-        },
-    };
-    it('should correctly parse data', () => {
-        expect(parseGroupsStatsQueryResponse(dataSet1)).toEqual(parsedDataSet1);
-        expect(parseGroupsStatsQueryResponse(dataSet2)).toEqual(parsedDataSet2);
-    });
-});

package/dist/store/reducers/cluster/cluster.ts

@@ -1,95 +0,0 @@
-import type {Reducer} from 'redux';
-
-import '../../../services/api';
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-import type {ClusterAction, ClusterState} from './types';
-import {createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse} from './utils';
-
-export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
-
-const initialState = {loading: true, wasLoaded: false};
-
-const cluster: Reducer<ClusterState, ClusterAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_CLUSTER.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_CLUSTER.SUCCESS: {
-            const {clusterData, groupsStats} = action.data;
-
-            return {
-                ...state,
-                data: clusterData,
-                groupsStats,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_CLUSTER.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export function getClusterInfo(clusterName?: string) {
-    async function requestClusterData() {
-        // Error here is handled by createApiRequest
-        const clusterData = await window.api.getClusterInfo(clusterName);
-
-        try {
-            const clusterRoot = clusterData.Domain;
-
-            // Without domain we cannot get stats from system tables
-            if (!clusterRoot) {
-                return {
-                    clusterData,
-                };
-            }
-
-            const query = createSelectClusterGroupsQuery(clusterRoot);
-
-            // Normally query request should be fulfilled within 300-400ms even on very big clusters
-            // Table with stats is supposed to be very small (less than 10 rows)
-            // So we batch this request with cluster request to prevent possible layout shifts, if data is missing
-            const groupsStatsResponse = await window.api.sendQuery({
-                schema: 'modern',
-                query: query,
-                database: clusterRoot,
-                action: 'execute-scan',
-            });
-
-            return {
-                clusterData,
-                groupsStats: parseGroupsStatsQueryResponse(groupsStatsResponse),
-            };
-        } catch {
-            // Doesn't return groups stats on error
-            // It could happen if user doesn't have access rights
-            // Or there are no system tables in cluster root
-            return {
-                clusterData,
-            };
-        }
-    }
-
-    return createApiRequest({
-        request: requestClusterData(),
-        actions: FETCH_CLUSTER,
-    });
-}
-
-export default cluster;

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

@@ -1,39 +0,0 @@
-import type {TClusterInfo} from '../../../types/api/cluster';
-import type {IResponseError} from '../../../types/api/error';
-import type {ApiRequestAction} from '../../utils';
-
-import {FETCH_CLUSTER} from './cluster';
-
-export interface DiskErasureGroupsStats {
-    diskType: string;
-    erasure: string;
-    createdGroups: number;
-    totalGroups: number;
-    allocatedSize: number;
-    availableSize: number;
-}
-
-/** Keys - erasure types */
-export type DiskGroupsStats = Record<string, DiskErasureGroupsStats>;
-
-/** Keys - PDisks types */
-export type ClusterGroupsStats = Record<string, DiskGroupsStats>;
-
-export interface ClusterState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: TClusterInfo;
-    error?: IResponseError;
-    groupsStats?: ClusterGroupsStats;
-}
-
-export interface HandledClusterResponse {
-    clusterData: TClusterInfo;
-    groupsStats: ClusterGroupsStats;
-}
-
-export type ClusterAction = ApiRequestAction<
-    typeof FETCH_CLUSTER,
-    HandledClusterResponse,
-    IResponseError
->;

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

@@ -1,88 +0,0 @@
-import type {ExecuteQueryResponse} from '../../../types/api/query';
-import {parseQueryAPIExecuteResponse} from '../../../utils/query';
-
-import type {ClusterGroupsStats} from './types';
-
-export const createSelectClusterGroupsQuery = (clusterRoot: string) => {
-    return `
-SELECT 
-    PDiskFilter,
-    ErasureSpecies,
-    CurrentAvailableSize,
-    CurrentAllocatedSize,
-    CurrentGroupsCreated,
-    AvailableGroupsToCreate
-    FROM \`${clusterRoot}/.sys/ds_storage_stats\`
-    ORDER BY CurrentGroupsCreated DESC;
-`;
-};
-
-const getDiskType = (rawTypeString: string) => {
-    // Check if value math regexp and put disk type in type group
-    const diskTypeRe = /^Type:(?<type>[A-Za-z]+)/;
-
-    const diskType = rawTypeString.match(diskTypeRe)?.groups?.['type'];
-
-    if (diskType === 'ROT') {
-        // Display ROT as HDD
-        return 'HDD';
-    }
-
-    return diskType;
-};
-
-export const parseGroupsStatsQueryResponse = (
-    data: ExecuteQueryResponse<'modern'>,
-): ClusterGroupsStats => {
-    const parsedData = parseQueryAPIExecuteResponse(data).result;
-    const result: ClusterGroupsStats = {};
-
-    parsedData?.forEach((stats) => {
-        const {
-            PDiskFilter,
-            ErasureSpecies: erasure,
-            CurrentAvailableSize,
-            CurrentAllocatedSize,
-            CurrentGroupsCreated,
-            AvailableGroupsToCreate,
-        } = stats;
-
-        const createdGroups = Number(CurrentGroupsCreated) || 0;
-        const availableGroupsToCreate = Number(AvailableGroupsToCreate) || 0;
-        const totalGroups = createdGroups + availableGroupsToCreate;
-        const allocatedSize = Number(CurrentAllocatedSize) || 0;
-        const availableSize = Number(CurrentAvailableSize) || 0;
-        const diskType = PDiskFilter && typeof PDiskFilter === 'string' && getDiskType(PDiskFilter);
-
-        if (diskType && erasure && typeof erasure === 'string' && createdGroups) {
-            const preparedStats = {
-                diskType,
-                erasure,
-                createdGroups,
-                totalGroups,
-                allocatedSize,
-                availableSize,
-            };
-
-            if (result[diskType]) {
-                if (result[diskType][erasure]) {
-                    const currentValue = {...result[diskType][erasure]};
-                    result[diskType][erasure] = {
-                        diskType,
-                        erasure,
-                        createdGroups: currentValue.createdGroups + createdGroups,
-                        totalGroups: currentValue.totalGroups + totalGroups,
-                        allocatedSize: currentValue.allocatedSize + allocatedSize,
-                        availableSize: currentValue.availableSize + availableSize,
-                    };
-                } else {
-                    result[diskType][erasure] = preparedStats;
-                }
-            } else {
-                result[diskType] = {[erasure]: preparedStats};
-            }
-        }
-    });
-
-    return result;
-};

package/dist/store/reducers/clusterNodes/clusterNodes.tsx

@@ -1,68 +0,0 @@
-import {Reducer} from 'redux';
-
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-
-import type {ClusterNodesAction, ClusterNodesState, PreparedClusterNode} from './types';
-
-import '../../../services/api';
-import {calcUptime} from '../../../utils/dataFormatters/dataFormatters';
-
-export const FETCH_CLUSTER_NODES = createRequestActionTypes('cluster', 'FETCH_CLUSTER_NODES');
-
-const initialState = {loading: false, wasLoaded: false};
-
-const clusterNodes: Reducer<ClusterNodesState, ClusterNodesAction> = (
-    state = initialState,
-    action,
-) => {
-    switch (action.type) {
-        case FETCH_CLUSTER_NODES.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_CLUSTER_NODES.SUCCESS: {
-            const {data = []} = action;
-
-            return {
-                ...state,
-                nodes: data,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_CLUSTER_NODES.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export function getClusterNodes() {
-    return createApiRequest({
-        request: window.api.getClusterNodes(),
-        actions: FETCH_CLUSTER_NODES,
-        dataHandler: (data): PreparedClusterNode[] => {
-            const {SystemStateInfo: nodes = []} = data;
-            return nodes.map((node) => {
-                return {
-                    ...node,
-                    uptime: calcUptime(node.StartTime),
-                };
-            });
-        },
-    });
-}
-
-export default clusterNodes;

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

@@ -1,22 +0,0 @@
-import type {IResponseError} from '../../../types/api/error';
-import type {TSystemStateInfo} from '../../../types/api/nodes';
-import type {ApiRequestAction} from '../../utils';
-
-import {FETCH_CLUSTER_NODES} from './clusterNodes';
-
-export interface PreparedClusterNode extends TSystemStateInfo {
-    uptime: string;
-}
-
-export interface ClusterNodesState {
-    loading: boolean;
-    wasLoaded: boolean;
-    nodes?: PreparedClusterNode[];
-    error?: IResponseError;
-}
-
-export type ClusterNodesAction = ApiRequestAction<
-    typeof FETCH_CLUSTER_NODES,
-    PreparedClusterNode[],
-    IResponseError
->;

package/dist/store/reducers/describe.ts

@@ -1,145 +0,0 @@
-import {Reducer} from 'redux';
-
-import '../../services/api';
-import type {
-    IDescribeState,
-    IDescribeAction,
-    IDescribeHandledResponse,
-    IDescribeData,
-} from '../../types/store/describe';
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-export const FETCH_DESCRIBE = createRequestActionTypes('describe', 'FETCH_DESCRIBE');
-const SET_CURRENT_DESCRIBE_PATH = 'describe/SET_CURRENT_DESCRIBE_PATH';
-const SET_DATA_WAS_NOT_LOADED = 'describe/SET_DATA_WAS_NOT_LOADED';
-
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-    data: {},
-    currentDescribe: undefined,
-    currentDescribePath: undefined,
-};
-
-const describe: Reducer<IDescribeState, IDescribeAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_DESCRIBE.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_DESCRIBE.SUCCESS: {
-            const isCurrentDescribePath = action.data.path === state.currentDescribePath;
-            const newData = {...state.data, ...action.data.data};
-
-            if (!isCurrentDescribePath) {
-                return {
-                    ...state,
-                    data: newData,
-                };
-            }
-
-            return {
-                ...state,
-                data: newData,
-                currentDescribe: action.data.currentDescribe,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-
-        case FETCH_DESCRIBE.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        case SET_CURRENT_DESCRIBE_PATH: {
-            return {
-                ...state,
-                currentDescribePath: action.data,
-            };
-        }
-        case SET_DATA_WAS_NOT_LOADED: {
-            return {
-                ...state,
-                wasLoaded: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export const setCurrentDescribePath = (path: string) => {
-    return {
-        type: SET_CURRENT_DESCRIBE_PATH,
-        data: path,
-    } as const;
-};
-
-export const setDataWasNotLoaded = () => {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    } as const;
-};
-
-export function getDescribe({path}: {path: string}) {
-    const request = window.api.getDescribe({path});
-    return createApiRequest({
-        request,
-        actions: FETCH_DESCRIBE,
-        dataHandler: (data): IDescribeHandledResponse => {
-            const dataPath = data.Path;
-            const currentDescribe: IDescribeData = {};
-            const newData: IDescribeData = {};
-
-            if (dataPath) {
-                currentDescribe[dataPath] = data;
-                newData[dataPath] = data;
-            }
-
-            return {
-                path: dataPath,
-                currentDescribe,
-                data: newData,
-            };
-        },
-    });
-}
-
-export function getDescribeBatched(paths: string[]) {
-    const requestsArray = paths.map((p) => window.api.getDescribe({path: p}));
-
-    const request = Promise.all(requestsArray);
-    return createApiRequest({
-        request,
-        actions: FETCH_DESCRIBE,
-        dataHandler: (data): IDescribeHandledResponse => {
-            const currentDescribe: IDescribeData = {};
-            const newData: IDescribeData = {};
-
-            data.forEach((dataItem) => {
-                if (dataItem.Path) {
-                    newData[dataItem.Path] = dataItem;
-                    currentDescribe[dataItem.Path] = dataItem;
-                }
-            });
-
-            return {
-                path: data[0].Path,
-                currentDescribe,
-                data: newData,
-            };
-        },
-    });
-}
-
-export default describe;