ydb-embedded-ui 2.4.4 → 2.6.0

package/dist/store/reducers/describe.ts

@@ -3,7 +3,13 @@ import {Reducer} from 'redux';
 
 import '../../services/api';
 import {IConsumer} from '../../types/api/consumers';
-import {IDescribeRootStateSlice, IDescribeState, IDescribeAction} from '../../types/store/describe';
+import {
+    IDescribeRootStateSlice,
+    IDescribeState,
+    IDescribeAction,
+    IDescribeHandledResponse,
+    IDescribeData,
+} from '../../types/store/describe';
 import {createRequestActionTypes, createApiRequest} from '../utils';
 
 export const FETCH_DESCRIBE = createRequestActionTypes('describe', 'FETCH_DESCRIBE');
@@ -27,16 +33,8 @@ const describe: Reducer<IDescribeState, IDescribeAction> = (state = initialState
             };
         }
         case FETCH_DESCRIBE.SUCCESS: {
-            const data = action.data;
-
-            const isCurrentDescribePath = data.Path === state.currentDescribePath;
-
-            let newData = state.data;
-
-            if (data.Path) {
-                newData = JSON.parse(JSON.stringify(state.data));
-                newData[data.Path] = data;
-            }
+            const isCurrentDescribePath = action.data.path === state.currentDescribePath;
+            const newData = {...state.data, ...action.data.data};
 
             if (!isCurrentDescribePath) {
                 return {
@@ -48,7 +46,7 @@ const describe: Reducer<IDescribeState, IDescribeAction> = (state = initialState
             return {
                 ...state,
                 data: newData,
-                currentDescribe: data,
+                currentDescribe: action.data.currentDescribe,
                 loading: false,
                 wasLoaded: true,
                 error: undefined,
@@ -97,7 +95,7 @@ export const setDataWasNotLoaded = () => {
 };
 
 // Consumers selectors
-const selectConsumersNames = (state: IDescribeRootStateSlice, path: string | undefined) =>
+const selectConsumersNames = (state: IDescribeRootStateSlice, path?: string) =>
     path
         ? state.describe.data[path]?.PathDescription?.PersQueueGroup?.PQTabletConfig?.ReadRules
         : undefined;
@@ -106,9 +104,53 @@ export const selectConsumers: Selector<IDescribeRootStateSlice, IConsumer[], [st
     createSelector(selectConsumersNames, (names = []) => names.map((name) => ({name})));
 
 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: window.api.getDescribe({path}),
+        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,
+            };
+        },
     });
 }
 

package/dist/store/reducers/healthcheckInfo.ts

@@ -9,21 +9,23 @@ import {
     IHealthcheckInfoState,
     IHealthcheckInfoRootStateSlice,
     IIssuesTree,
+    IHealthCheckInfoAction,
 } from '../../types/store/healthcheck';
-import {HealthCheckAPIResponse, IssueLog, StatusFlag} from '../../types/api/healthcheck';
-import {IResponseError} from '../../types/api/error';
+import {IssueLog, StatusFlag} from '../../types/api/healthcheck';
 
 import '../../services/api';
-import {createRequestActionTypes, createApiRequest, ApiRequestAction} from '../utils';
+import {createRequestActionTypes, createApiRequest} from '../utils';
 
-const FETCH_HEALTHCHECK = createRequestActionTypes('cluster', 'FETCH_HEALTHCHECK');
+export const FETCH_HEALTHCHECK = createRequestActionTypes('cluster', 'FETCH_HEALTHCHECK');
+
+const SET_DATA_WAS_NOT_LOADED = 'healthcheckInfo/SET_DATA_WAS_NOT_LOADED';
 
 const initialState = {loading: false, wasLoaded: false};
 
-const healthcheckInfo: Reducer<
-    IHealthcheckInfoState,
-    ApiRequestAction<typeof FETCH_HEALTHCHECK, HealthCheckAPIResponse, IResponseError>
-> = function (state = initialState, action) {
+const healthcheckInfo: Reducer<IHealthcheckInfoState, IHealthCheckInfoAction> = function (
+    state = initialState,
+    action,
+) {
     switch (action.type) {
         case FETCH_HEALTHCHECK.REQUEST: {
             return {
@@ -49,6 +51,13 @@ const healthcheckInfo: Reducer<
                 loading: false,
             };
         }
+
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
         default:
             return state;
     }
@@ -127,4 +136,10 @@ export function getHealthcheckInfo(database: string) {
     });
 }
 
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+};
+
 export default healthcheckInfo;

package/dist/store/reducers/network.js

@@ -6,7 +6,15 @@ const FETCH_ALL_NODES_NETWORK = createRequestActionTypes(
     'FETCH_ALL_NODES_NETWORK',
 );
 
-const network = (state = {data: {}, loading: true, wasLoaded: false}, action) => {
+const SET_DATA_WAS_NOT_LOADED = 'network/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    data: {},
+    loading: false,
+    wasLoaded: false,
+};
+
+const network = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_ALL_NODES_NETWORK.REQUEST: {
             return {
@@ -30,11 +38,24 @@ const network = (state = {data: {}, loading: true, wasLoaded: false}, action) =>
                 loading: false,
             };
         }
+
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
         default:
             return state;
     }
 };
 
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+
 export const getNetworkInfo = (tenant) => {
     return createApiRequest({
         request: window.api.getNetwork(tenant),

package/dist/store/reducers/nodes.js

@@ -1,9 +1,20 @@
 import {createRequestActionTypes, createApiRequest} from '../utils';
 import '../../services/api';
+import {NodesUptimeFilterValues} from '../../utils/nodes';
 
 const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
 
-const nodes = function z(state = {loading: true, wasLoaded: false}, action) {
+const CLEAR_NODES = 'nodes/CLEAR_NODES';
+const SET_NODES_UPTIME_FILTER = 'nodes/SET_NODES_UPTIME_FILTER';
+const SET_DATA_WAS_NOT_LOADED = 'nodes/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+    nodesUptimeFilter: NodesUptimeFilterValues.All,
+};
+
+const nodes = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_NODES.REQUEST: {
             return {
@@ -28,7 +39,7 @@ const nodes = function z(state = {loading: true, wasLoaded: false}, action) {
                 loading: false,
             };
         }
-        case 'CLEAR_NODES': {
+        case CLEAR_NODES: {
             return {
                 ...state,
                 loading: true,
@@ -38,6 +49,16 @@ const nodes = function z(state = {loading: true, wasLoaded: false}, action) {
                 error: undefined,
             };
         }
+
+        case SET_NODES_UPTIME_FILTER: {
+            return {...state, nodesUptimeFilter: action.data};
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
         default:
             return state;
     }
@@ -50,6 +71,19 @@ export function getNodes(path) {
     });
 }
 
-export const clearNodes = () => ({type: 'CLEAR_NODES'});
+export const clearNodes = () => ({type: CLEAR_NODES});
+
+export const setNodesUptimeFilter = (value) => ({
+    type: SET_NODES_UPTIME_FILTER,
+    data: value,
+});
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+
+export const getNodesUptimeFilter = (state) => state.nodes.nodesUptimeFilter;
 
 export default nodes;

package/dist/store/reducers/schema.ts

@@ -0,0 +1,229 @@
+import {Reducer} from 'redux';
+import {createSelector, Selector} from 'reselect';
+
+import {
+    ISchemaAction,
+    ISchemaData,
+    ISchemaHandledResponse,
+    ISchemaRootStateSlice,
+    ISchemaState,
+} from '../../types/store/schema';
+import {EPathType} from '../../types/api/schema';
+import '../../services/api';
+import {isEntityWithMergedImplementation} from '../../containers/Tenant/utils/schema';
+
+import {createRequestActionTypes, createApiRequest} from '../utils';
+
+export const FETCH_SCHEMA = createRequestActionTypes('schema', 'FETCH_SCHEMA');
+const PRELOAD_SCHEMAS = 'schema/PRELOAD_SCHEMAS';
+const SET_SCHEMA = 'schema/SET_SCHEMA';
+const SET_SHOW_PREVIEW = 'schema/SET_SHOW_PREVIEW';
+const ENABLE_AUTOREFRESH = 'schema/ENABLE_AUTOREFRESH';
+const DISABLE_AUTOREFRESH = 'schema/DISABLE_AUTOREFRESH';
+const RESET_LOADING_STATE = 'schema/RESET_LOADING_STATE';
+
+export const initialState = {
+    loading: true,
+    wasLoaded: false,
+    data: {},
+    currentSchemaPath: undefined,
+    autorefresh: false,
+    showPreview: false,
+};
+
+const schema: Reducer<ISchemaState, ISchemaAction> = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_SCHEMA.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_SCHEMA.SUCCESS: {
+            const isCurrentSchema =
+                !state.currentSchemaPath || state.currentSchemaPath === action.data.path;
+
+            const newData = {...state.data, ...action.data.data};
+
+            if (!isCurrentSchema) {
+                return {
+                    ...state,
+                    data: newData,
+                };
+            }
+
+            return {
+                ...state,
+                error: undefined,
+                data: newData,
+                currentSchema: action.data.currentSchema,
+                currentSchemaPath: action.data.path,
+                loading: false,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_SCHEMA.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case PRELOAD_SCHEMAS: {
+            return {
+                ...state,
+                data: {
+                    // we don't want to overwrite existing paths
+                    ...action.data,
+                    ...state.data,
+                },
+            };
+        }
+        case SET_SCHEMA: {
+            return {
+                ...state,
+                currentSchemaPath: action.data,
+                wasLoaded: false,
+            };
+        }
+        case ENABLE_AUTOREFRESH: {
+            return {
+                ...state,
+                autorefresh: true,
+            };
+        }
+        case DISABLE_AUTOREFRESH: {
+            return {
+                ...state,
+                autorefresh: false,
+            };
+        }
+        case SET_SHOW_PREVIEW: {
+            return {
+                ...state,
+                showPreview: action.data,
+            };
+        }
+        case RESET_LOADING_STATE: {
+            return {
+                ...state,
+                wasLoaded: initialState.wasLoaded,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getSchema({path}: {path: string}) {
+    const request = window.api.getSchema({path});
+    return createApiRequest({
+        request,
+        actions: FETCH_SCHEMA,
+        dataHandler: (data): ISchemaHandledResponse => {
+            const newData: ISchemaData = {};
+            if (data.Path) {
+                newData[data.Path] = data;
+            }
+            return {
+                path: data.Path,
+                currentSchema: data,
+                data: newData,
+            };
+        },
+    });
+}
+
+export function getSchemaBatched(paths: string[]) {
+    const requestArray = paths.map((p) =>
+        window.api.getSchema({path: p}, {concurrentId: `getSchemaBatched|${p}`}),
+    );
+    const request = Promise.all(requestArray);
+
+    return createApiRequest({
+        request,
+        actions: FETCH_SCHEMA,
+        dataHandler: (data): ISchemaHandledResponse => {
+            const newData: ISchemaData = {};
+
+            data.forEach((dataItem) => {
+                if (dataItem.Path) {
+                    newData[dataItem.Path] = dataItem;
+                }
+            });
+
+            return {
+                path: data[0].Path,
+                currentSchema: data[0],
+                data: newData,
+            };
+        },
+    });
+}
+
+export function setCurrentSchemaPath(currentSchemaPath: string) {
+    return {
+        type: SET_SCHEMA,
+        data: currentSchemaPath,
+    } as const;
+}
+export function enableAutorefresh() {
+    return {
+        type: ENABLE_AUTOREFRESH,
+    } as const;
+}
+export function disableAutorefresh() {
+    return {
+        type: DISABLE_AUTOREFRESH,
+    } as const;
+}
+export function setShowPreview(value: boolean) {
+    return {
+        type: SET_SHOW_PREVIEW,
+        data: value,
+    } as const;
+}
+
+// only stores data for paths that are not in the store yet
+// existing paths are ignored
+export function preloadSchemas(data: ISchemaData) {
+    return {
+        type: PRELOAD_SCHEMAS,
+        data,
+    } as const;
+}
+
+export function resetLoadingState() {
+    return {
+        type: RESET_LOADING_STATE,
+    } as const;
+}
+
+export const selectSchemaChildren = (state: ISchemaRootStateSlice, path?: string) =>
+    path ? state.schema.data[path]?.PathDescription?.Children : undefined;
+
+export const selectSchemaData = (state: ISchemaRootStateSlice, path?: string) =>
+    path ? state.schema.data[path] : undefined;
+
+export const selectSchemaMergedChildrenPaths: Selector<
+    ISchemaRootStateSlice,
+    string[] | undefined,
+    [string | undefined, EPathType | undefined]
+> = createSelector(
+    [
+        (_, path?: string) => path,
+        (_, _path, type: EPathType | undefined) => type,
+        selectSchemaChildren,
+    ],
+    (path, type, children) => {
+        return isEntityWithMergedImplementation(type)
+            ? children?.map(({Name}) => path + '/' + Name)
+            : undefined;
+    },
+);
+
+export default schema;

package/dist/store/reducers/storage.js

@@ -1,10 +1,14 @@
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import '../../services/api';
 import _ from 'lodash';
 import {createSelector} from 'reselect';
-import {calcUptime} from '../../utils';
+
+import {calcUptime, calcUptimeInSeconds} from '../../utils';
 import {getUsage} from '../../utils/storage';
+import {NodesUptimeFilterValues} from '../../utils/nodes';
 import {getPDiskType} from '../../utils/pdisk';
+import {HOUR_IN_SECONDS} from '../../utils/constants';
+import '../../services/api';
+
+import {createRequestActionTypes, createApiRequest} from '../utils';
 
 export const VisibleEntities = {
     All: 'All',
@@ -29,6 +33,8 @@ 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 initialState = {
     loading: true,
@@ -36,6 +42,7 @@ const initialState = {
     filter: '',
     usageFilter: [],
     visible: VisibleEntities.Missing,
+    nodesUptimeFilter: NodesUptimeFilterValues.All,
     type: StorageTypes.groups,
 };
 
@@ -93,6 +100,13 @@ const storage = (state = initialState, action) => {
                 error: undefined,
             };
         }
+
+        case SET_NODES_UPTIME_FILTER: {
+            return {
+                ...state,
+                nodesUptimeFilter: action.data,
+            };
+        }
         case SET_STORAGE_TYPE: {
             return {
                 ...state,
@@ -103,6 +117,12 @@ const storage = (state = initialState, action) => {
                 error: undefined,
             };
         }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
         default:
             return state;
     }
@@ -149,6 +169,19 @@ export function setVisibleEntities(value) {
     };
 }
 
+export function setNodesUptimeFilter(value) {
+    return {
+        type: SET_NODES_UPTIME_FILTER,
+        data: value,
+    };
+}
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+
 export const getStoragePools = (state) => state.storage.data?.StoragePools;
 export const getStoragePoolsGroupsCount = (state) => ({
     total: state.storage.data?.TotalGroups || 0,
@@ -162,6 +195,7 @@ export const getStorageNodesCount = (state) => ({
 export const getStorageFilter = (state) => state.storage.filter;
 export const getUsageFilter = (state) => state.storage.usageFilter;
 export const getVisibleEntities = (state) => state.storage.visible;
+export const getNodesUptimeFilter = (state) => state.storage.nodesUptimeFilter;
 export const getStorageType = (state) => state.storage.type;
 export const getNodesObject = (state) =>
     _.reduce(
@@ -337,12 +371,32 @@ const filterByUsage = (entities, usage) => {
     });
 };
 
+export const filterByUptime = (nodes = [], nodesUptimeFilter) => {
+    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
+        return nodes;
+    }
+    return nodes.filter(({StartTime}) => {
+        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
+    });
+};
+
 export const getFilteredEntities = createSelector(
-    [getStorageFilter, getUsageFilter, getStorageType, getVisibleEntitiesList],
-    (textFilter, usageFilter, type, entities) => {
+    [
+        getStorageFilter,
+        getUsageFilter,
+        getStorageType,
+        getNodesUptimeFilter,
+        getVisibleEntitiesList,
+    ],
+    (textFilter, usageFilter, type, nodesUptimeFilter, entities) => {
         let result = entities;
         result = filterByText(result, type, textFilter);
         result = filterByUsage(result, usageFilter);
+
+        if (type === StorageTypes.nodes) {
+            result = filterByUptime(result, nodesUptimeFilter);
+        }
+
         return result;
     },
 );

package/dist/types/api/enums.ts

@@ -0,0 +1,10 @@
+// Shows system status
+// Currently is used in response types of viewer/json/nodes and viewer/json/storage
+// Probably will appear in /viewer/json/tenantinfo /viewer/json/cluster /viewer/json/tabletinfo /viewer/json/compute
+export enum EFlag {
+    Grey = 'Grey',
+    Green = 'Green',
+    Yellow = 'Yellow',
+    Orange = 'Orange',
+    Red = 'Red',
+}