ydb-embedded-ui 4.33.0 → 5.1.0

package/dist/store/index.d.ts

@@ -0,0 +1,97 @@
+export function configureStore({ aRootReducer, singleClusterMode, api, }?: {
+    aRootReducer?: import("redux").Reducer<import("redux").CombinedState<{
+        singleClusterMode: boolean;
+        nodes: import("./reducers/nodes/types").NodesState;
+        topNodesByLoad: import("./reducers/tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+        topNodesByCpu: import("./reducers/tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+        topNodesByMemory: import("./reducers/tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+        cluster: import("./reducers/cluster/types").ClusterState;
+        clusterNodes: import("./reducers/clusterNodes/types").ClusterNodesState;
+        tenant: import("./reducers/tenant/types").TenantState;
+        storage: import("./reducers/storage/types").StorageState;
+        topStorageGroups: import("./reducers/tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+        node: import("./reducers/node/types").NodeState;
+        tooltip: import("../types/store/tooltip").ITooltipState;
+        tablets: import("../types/store/tablets").ITabletsState;
+        schema: import("./reducers/schema/types").SchemaState;
+        overview: import("./reducers/overview/types").OverviewState;
+        olapStats: import("../types/store/olapStats").OlapStatsState;
+        host: import("../types/store/host").IHostState;
+        network: import("./reducers/network/types").NetworkState;
+        tenants: import("./reducers/tenants/types").TenantsState;
+        tablet: import("../types/store/tablet").ITabletState;
+        topic: import("../types/store/topic").ITopicState;
+        partitions: import("./reducers/partitions/types").PartitionsState;
+        executeQuery: import("../types/store/executeQuery").ExecuteQueryState;
+        explainQuery: import("../types/store/explainQuery").ExplainQueryState;
+        tabletsFilters: {
+            loading: boolean;
+            requestTime: number;
+            data: undefined;
+            wasLoaded: boolean;
+            stateFilter: never[];
+            typeFilter: never[];
+        } | {
+            tabletsData: any;
+            nodes: any;
+            loading: boolean;
+            wasLoaded: boolean;
+            timeoutForRequest: number;
+            error: undefined;
+            data: undefined;
+            stateFilter: never[];
+            typeFilter: never[];
+        } | {
+            error: any;
+            loading: boolean;
+            data: undefined;
+            wasLoaded: boolean;
+            stateFilter: never[];
+            typeFilter: never[];
+        } | {
+            stateFilter: any;
+            data: undefined;
+            loading: boolean;
+            wasLoaded: boolean;
+            typeFilter: never[];
+        } | {
+            typeFilter: any;
+            data: undefined;
+            loading: boolean;
+            wasLoaded: boolean;
+            stateFilter: never[];
+        };
+        heatmap: import("../types/store/heatmap").IHeatmapState;
+        settings: import("./reducers/settings/types").SettingsState;
+        preview: any;
+        nodesList: import("../types/store/nodesList").NodesListState;
+        describe: import("../types/store/describe").IDescribeState;
+        schemaAcl: import("./reducers/schemaAcl/types").SchemaAclState;
+        executeTopQueries: import("./reducers/executeTopQueries/types").ITopQueriesState;
+        executeTopTables: import("./reducers/tenantOverview/executeTopTables/types").TopTablesState;
+        tenantOverviewTopQueries: import("./reducers/tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+        healthcheckInfo: import("../types/store/healthcheck").IHealthcheckInfoState;
+        shardsWorkload: import("./reducers/shardsWorkload/types").IShardsWorkloadState;
+        tenantOverviewTopShards: import("./reducers/tenantOverview/topShards/types").TenantOverviewTopShardsState;
+        hotKeys: import("./reducers/hotKeys/types").HotKeysState;
+        authentication: import("./reducers/authentication/types").AuthenticationState;
+        header: import("./reducers/header/types").HeaderState;
+        saveQuery: string | null;
+        fullscreen: boolean;
+        clusters: import("./reducers/clusters/types").ClustersState;
+    }>, any> | undefined;
+    singleClusterMode?: boolean | undefined;
+    api?: import("../services/api").YdbEmbeddedAPI | undefined;
+}): {
+    history: import("history").History<unknown>;
+    store: import("redux").Store<any, any> & {
+        dispatch: any;
+    };
+};
+export let backend: any;
+export let basename: any;
+export let clusterName: any;
+export const webVersion: boolean | undefined;
+export const customBackend: string | undefined;
+export const metaBackend: any;
+export * from "./reducers";

package/dist/store/index.js

@@ -1,37 +1,49 @@
-import {createStore, applyMiddleware, compose} from 'redux';
+import { createStore, applyMiddleware, compose } from 'redux';
 import thunkMiddleware from 'redux-thunk';
-import {createBrowserHistory} from 'history';
-import {listenForHistoryChange} from 'redux-location-state';
-
-import {getUrlData} from './getUrlData';
+import { createBrowserHistory } from 'history';
+import { listenForHistoryChange } from 'redux-location-state';
+import { getUrlData } from './getUrlData';
 import getLocationMiddleware from './state-url-mapping';
 import rootReducer from './reducers';
-
+import { createApi } from '../services/api';
 export let backend, basename, clusterName;
-
 const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
-
 function _configureStore(aRootReducer, history, singleClusterMode) {
-    const {locationMiddleware, reducersWithLocation} = getLocationMiddleware(history, aRootReducer);
+    const { locationMiddleware, reducersWithLocation } = getLocationMiddleware(history, aRootReducer);
     const middlewares = applyMiddleware(thunkMiddleware, locationMiddleware);
-
     return composeEnhancers(middlewares)(createStore)(reducersWithLocation, {
         singleClusterMode,
     });
 }
-
-function configureStore(aRootReducer = rootReducer, singleClusterMode = true) {
-    ({backend, basename, clusterName} = getUrlData(window.location.href, singleClusterMode));
-    const history = createBrowserHistory({basename});
-
+export const webVersion = window.web_version;
+export const customBackend = window.custom_backend;
+export const metaBackend = window.meta_backend;
+const isSingleClusterMode = `${metaBackend}` === 'undefined';
+export function configureStore({ aRootReducer = rootReducer, singleClusterMode = isSingleClusterMode, api = createApi({ webVersion, withCredentials: !customBackend }), } = {}) {
+    ({ backend, basename, clusterName } = getUrlData({
+        href: window.location.href,
+        singleClusterMode,
+        customBackend,
+    }));
+    const history = createBrowserHistory({ basename });
     const store = _configureStore(aRootReducer, history, singleClusterMode);
     listenForHistoryChange(store, history);
-    return {history, store};
+    // Interceptor to process OIDC auth
+    api._axios.interceptors.response.use(function (response) {
+        return Promise.resolve(response);
+    }, function (error) {
+        var _a;
+        const response = error.response;
+        // OIDC proxy returns 401 response with authUrl in it
+        // authUrl - external auth service link, after successful auth additional cookies will be appended
+        // that will allow access to clusters where OIDC proxy is a balancer
+        if (response && response.status === 401 && ((_a = response.data) === null || _a === void 0 ? void 0 : _a.authUrl)) {
+            return window.location.assign(response.data.authUrl);
+        }
+        return Promise.reject(error);
+    });
+    window.api = api;
+    window.store = store; // TODO: check is it really needed
+    return { history, store };
 }
-
-export const webVersion = window.web_version;
-export const customBackend = window.custom_backend;
-
 export * from './reducers';
-
-export default configureStore;

package/dist/store/reducers/authentication/authentication.d.ts

@@ -0,0 +1,22 @@
+import type { Reducer } from 'redux';
+import type { AuthenticationAction, AuthenticationState } from './types';
+export declare const SET_UNAUTHENTICATED: {
+    readonly REQUEST: "authentication/SET_UNAUTHENTICATED_REQUEST";
+    readonly SUCCESS: "authentication/SET_UNAUTHENTICATED_SUCCESS";
+    readonly FAILURE: "authentication/SET_UNAUTHENTICATED_FAILURE";
+};
+export declare const SET_AUTHENTICATED: {
+    readonly REQUEST: "authentication/SET_AUTHENTICATED_REQUEST";
+    readonly SUCCESS: "authentication/SET_AUTHENTICATED_SUCCESS";
+    readonly FAILURE: "authentication/SET_AUTHENTICATED_FAILURE";
+};
+export declare const FETCH_USER: {
+    readonly REQUEST: "authentication/FETCH_USER_REQUEST";
+    readonly SUCCESS: "authentication/FETCH_USER_SUCCESS";
+    readonly FAILURE: "authentication/FETCH_USER_FAILURE";
+};
+declare const authentication: Reducer<AuthenticationState, AuthenticationAction>;
+export declare const authenticate: (user: string, password: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare const logout: () => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare const getUser: () => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<string | undefined>;
+export default authentication;

package/dist/store/reducers/authentication/authentication.js

@@ -0,0 +1,50 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const SET_UNAUTHENTICATED = createRequestActionTypes('authentication', 'SET_UNAUTHENTICATED');
+export const SET_AUTHENTICATED = createRequestActionTypes('authentication', 'SET_AUTHENTICATED');
+export const FETCH_USER = createRequestActionTypes('authentication', 'FETCH_USER');
+const initialState = {
+    isAuthenticated: true,
+    user: '',
+    error: undefined,
+};
+const authentication = (state = initialState, action) => {
+    switch (action.type) {
+        case SET_UNAUTHENTICATED.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { isAuthenticated: false, user: '', error: undefined });
+        }
+        case SET_AUTHENTICATED.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { isAuthenticated: true, error: undefined });
+        }
+        case SET_AUTHENTICATED.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error });
+        }
+        case FETCH_USER.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { user: action.data });
+        }
+        default:
+            return Object.assign({}, state);
+    }
+};
+export const authenticate = (user, password) => {
+    return createApiRequest({
+        request: window.api.authenticate(user, password),
+        actions: SET_AUTHENTICATED,
+    });
+};
+export const logout = () => {
+    return createApiRequest({
+        request: window.api.logout(),
+        actions: SET_UNAUTHENTICATED,
+    });
+};
+export const getUser = () => {
+    return createApiRequest({
+        request: window.api.whoami(),
+        actions: FETCH_USER,
+        dataHandler: (data) => {
+            const { UserSID, AuthType } = data;
+            return AuthType === 'Login' ? UserSID : undefined;
+        },
+    });
+};
+export default authentication;

package/dist/store/reducers/authentication/types.d.ts

@@ -0,0 +1,9 @@
+import type { AuthErrorResponse } from '../../../types/api/error';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_USER, SET_AUTHENTICATED, SET_UNAUTHENTICATED } from './authentication';
+export interface AuthenticationState {
+    isAuthenticated: boolean;
+    user: string | undefined;
+    error: AuthErrorResponse | undefined;
+}
+export declare type AuthenticationAction = ApiRequestAction<typeof SET_UNAUTHENTICATED, unknown, unknown> | ApiRequestAction<typeof SET_AUTHENTICATED, unknown, AuthErrorResponse> | ApiRequestAction<typeof FETCH_USER, string | undefined, unknown>;

package/dist/store/reducers/authentication/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,117 @@
+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.d.ts

@@ -0,0 +1,16 @@
+import type { Dispatch, Reducer } from 'redux';
+import { ClusterTab } from '../../../containers/Cluster/utils';
+import type { ClusterAction, ClusterState } from './types';
+export declare const FETCH_CLUSTER: {
+    readonly REQUEST: "cluster/FETCH_CLUSTER_REQUEST";
+    readonly SUCCESS: "cluster/FETCH_CLUSTER_SUCCESS";
+    readonly FAILURE: "cluster/FETCH_CLUSTER_FAILURE";
+};
+declare const cluster: Reducer<ClusterState, ClusterAction>;
+export declare function setDefaultClusterTab(tab: ClusterTab): {
+    readonly type: "cluster/SET_DEFAULT_CLUSTER_TAB";
+    readonly data: ClusterTab;
+};
+export declare function updateDefaultClusterTab(tab: string): (dispatch: Dispatch) => void;
+export declare function getClusterInfo(clusterName?: string): (dispatch: Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export default cluster;

package/dist/store/reducers/cluster/cluster.js

@@ -0,0 +1,94 @@
+import { DEFAULT_CLUSTER_TAB_KEY } from '../../../utils/constants';
+import { clusterTabsIds, isClusterTab } from '../../../containers/Cluster/utils';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse } from './utils';
+const SET_DEFAULT_CLUSTER_TAB = 'cluster/SET_DEFAULT_CLUSTER_TAB';
+export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
+const defaultClusterTabLS = localStorage.getItem(DEFAULT_CLUSTER_TAB_KEY);
+let defaultClusterTab;
+if (isClusterTab(defaultClusterTabLS)) {
+    defaultClusterTab = defaultClusterTabLS;
+}
+else {
+    defaultClusterTab = clusterTabsIds.overview;
+}
+const initialState = { loading: true, wasLoaded: false, defaultClusterTab };
+const cluster = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_CLUSTER.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_CLUSTER.SUCCESS: {
+            const { clusterData, groupsStats } = action.data;
+            return Object.assign(Object.assign({}, state), { data: clusterData, groupsStats, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_CLUSTER.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_DEFAULT_CLUSTER_TAB: {
+            return Object.assign(Object.assign({}, state), { defaultClusterTab: action.data });
+        }
+        default:
+            return state;
+    }
+};
+export function setDefaultClusterTab(tab) {
+    return {
+        type: SET_DEFAULT_CLUSTER_TAB,
+        data: tab,
+    };
+}
+export function updateDefaultClusterTab(tab) {
+    return (dispatch) => {
+        if (isClusterTab(tab)) {
+            localStorage.setItem(DEFAULT_CLUSTER_TAB_KEY, tab);
+            dispatch(setDefaultClusterTab(tab));
+        }
+    };
+}
+export function getClusterInfo(clusterName) {
+    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 (_a) {
+            // 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.d.ts

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { ExecuteQueryResponse } from '../../../types/api/query';
+import type { ClusterGroupsStats } from './types';
+export declare const createSelectClusterGroupsQuery: (clusterRoot: string) => string;
+export declare const parseGroupsStatsQueryResponse: (data: ExecuteQueryResponse<'modern'>) => ClusterGroupsStats;

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

@@ -0,0 +1,68 @@
+import { parseQueryAPIExecuteResponse } from '../../../utils/query';
+export const createSelectClusterGroupsQuery = (clusterRoot) => {
+    return `
+SELECT 
+    PDiskFilter,
+    ErasureSpecies,
+    CurrentAvailableSize,
+    CurrentAllocatedSize,
+    CurrentGroupsCreated,
+    AvailableGroupsToCreate
+    FROM \`${clusterRoot}/.sys/ds_storage_stats\`
+    ORDER BY CurrentGroupsCreated DESC;
+`;
+};
+const getDiskType = (rawTypeString) => {
+    var _a, _b;
+    // Check if value math regexp and put disk type in type group
+    const diskTypeRe = /^Type:(?<type>[A-Za-z]+)/;
+    const diskType = (_b = (_a = rawTypeString.match(diskTypeRe)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b['type'];
+    if (diskType === 'ROT') {
+        // Display ROT as HDD
+        return 'HDD';
+    }
+    return diskType;
+};
+export const parseGroupsStatsQueryResponse = (data) => {
+    const parsedData = parseQueryAPIExecuteResponse(data).result;
+    const result = {};
+    parsedData === null || parsedData === void 0 ? void 0 : 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 = Object.assign({}, 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.d.ts

@@ -0,0 +1,10 @@
+import { Reducer } from 'redux';
+import type { ClusterNodesAction, ClusterNodesState, PreparedClusterNode } from './types';
+export declare const FETCH_CLUSTER_NODES: {
+    readonly REQUEST: "cluster/FETCH_CLUSTER_NODES_REQUEST";
+    readonly SUCCESS: "cluster/FETCH_CLUSTER_NODES_SUCCESS";
+    readonly FAILURE: "cluster/FETCH_CLUSTER_NODES_FAILURE";
+};
+declare const clusterNodes: Reducer<ClusterNodesState, ClusterNodesAction>;
+export declare function getClusterNodes(): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<PreparedClusterNode[] | undefined>;
+export default clusterNodes;

package/dist/store/reducers/clusterNodes/clusterNodes.js

@@ -0,0 +1,37 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
+export const FETCH_CLUSTER_NODES = createRequestActionTypes('cluster', 'FETCH_CLUSTER_NODES');
+const initialState = { loading: false, wasLoaded: false };
+const clusterNodes = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_CLUSTER_NODES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_CLUSTER_NODES.SUCCESS: {
+            const { data = [] } = action;
+            return Object.assign(Object.assign({}, state), { nodes: data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_CLUSTER_NODES.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        default:
+            return state;
+    }
+};
+export function getClusterNodes() {
+    return createApiRequest({
+        request: window.api.getClusterNodes(),
+        actions: FETCH_CLUSTER_NODES,
+        dataHandler: (data) => {
+            const { SystemStateInfo: nodes = [] } = data;
+            return nodes.map((node) => {
+                return Object.assign(Object.assign({}, node), { uptime: calcUptime(node.StartTime) });
+            });
+        },
+    });
+}
+export default clusterNodes;

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

@@ -0,0 +1,14 @@
+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 declare type ClusterNodesAction = ApiRequestAction<typeof FETCH_CLUSTER_NODES, PreparedClusterNode[], IResponseError>;