ydb-embedded-ui 4.19.3 → 4.20.1

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

@@ -1,6 +1,7 @@
-import type {TComputeInfo, TComputeNodeInfo} from '../../../types/api/compute';
+import type {TComputeInfo, TComputeNodeInfo, TComputeTenantInfo} from '../../../types/api/compute';
 import type {TNodesInfo} from '../../../types/api/nodes';
 import {calcUptime} from '../../../utils/dataFormatters/dataFormatters';
+import {generateEvaluator} from '../../../utils/generateEvaluator';
 
 import type {NodesHandledResponse, NodesPreparedEntity} from './types';
 
@@ -14,23 +15,30 @@ const prepareComputeNode = (node: TComputeNodeInfo, tenantName?: string) => {
     };
 };
 
-export const prepareComputeNodesData = (data: TComputeInfo): NodesHandledResponse => {
+export const prepareComputeNodes = (nodes?: TComputeNodeInfo[], tenants?: TComputeTenantInfo[]) => {
     const preparedNodes: NodesPreparedEntity[] = [];
 
     // First try to parse v2 response in case backend supports it
     // Else parse v1 response
-    if (data.Nodes) {
-        data.Nodes.forEach((node) => {
+
+    if (nodes) {
+        nodes.forEach((node) => {
             preparedNodes.push(prepareComputeNode(node));
         });
-    } else if (data.Tenants) {
-        for (const tenant of data.Tenants) {
+    } else if (tenants) {
+        for (const tenant of tenants) {
             tenant.Nodes?.forEach((node) => {
                 preparedNodes.push(prepareComputeNode(node, tenant.Name));
             });
         }
     }
 
+    return preparedNodes;
+};
+
+export const prepareComputeNodesData = (data: TComputeInfo): NodesHandledResponse => {
+    const preparedNodes = prepareComputeNodes(data.Nodes, data.Tenants);
+
     return {
         Nodes: preparedNodes,
         TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
@@ -57,3 +65,5 @@ export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
         FoundNodes: Number(data.FoundNodes),
     };
 };
+
+export const getLoadSeverityForNode = generateEvaluator(60, 80, ['success', 'warning', 'danger']);

package/dist/store/reducers/{shardsWorkload.ts → shardsWorkload/shardsWorkload.ts}

@@ -1,16 +1,10 @@
 import type {Reducer} from 'redux';
 
-import '../../services/api';
-import type {
-    IShardsWorkloadAction,
-    IShardsWorkloadFilters,
-    IShardsWorkloadState,
-} from '../../types/store/shardsWorkload';
-import {EShardsWorkloadMode} from '../../types/store/shardsWorkload';
-
-import {parseQueryAPIExecuteResponse} from '../../utils/query';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../../services/api';
+import {parseQueryAPIExecuteResponse} from '../../../utils/query';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
+import type {IShardsWorkloadAction, IShardsWorkloadFilters, IShardsWorkloadState} from './types';
+import {EShardsWorkloadMode} from './types';
 
 export const SEND_SHARD_QUERY = createRequestActionTypes('query', 'SEND_SHARD_QUERY');
 const SET_SHARD_STATE = 'query/SET_SHARD_STATE';

package/dist/{types/store/shardsWorkload.ts → store/reducers/shardsWorkload/types.ts}

@@ -1,10 +1,6 @@
-import {
-    SEND_SHARD_QUERY,
-    setShardsState,
-    setShardsQueryFilters,
-} from '../../store/reducers/shardsWorkload';
-import type {ApiRequestAction} from '../../store/utils';
-import type {IQueryResult, QueryErrorResponse} from './query';
+import {SEND_SHARD_QUERY, setShardsState, setShardsQueryFilters} from './shardsWorkload';
+import type {ApiRequestAction} from '../../utils';
+import type {IQueryResult, QueryErrorResponse} from '../../../types/store/query';
 
 export enum EShardsWorkloadMode {
     Immediate = 'immediate',

package/dist/store/reducers/tenantOverview/topNodesByCpu/topNodesByCpu.ts

@@ -0,0 +1,87 @@
+import type {Reducer} from 'redux';
+
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {createApiRequest, createRequestActionTypes} from '../../../utils';
+import {prepareNodesData} from '../../nodes/utils';
+import type {NodesApiRequestParams} from '../../nodes/types';
+import type {TopNodesByCpuAction, TopNodesByCpuState, TopPoolsStateSlice} from './types';
+
+export const FETCH_TOP_NODES_BY_CPU = createRequestActionTypes(
+    'topNodesByCpu',
+    'FETCH_TOP_NODES_BY_CPU',
+);
+const SET_DATA_WAS_NOT_LOADED = 'topNodesByCpu/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+export const topNodesByCpu: Reducer<TopNodesByCpuState, TopNodesByCpuAction> = (
+    state = initialState,
+    action,
+) => {
+    switch (action.type) {
+        case FETCH_TOP_NODES_BY_CPU.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_TOP_NODES_BY_CPU.SUCCESS: {
+            return {
+                ...state,
+                data: action.data?.Nodes,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TOP_NODES_BY_CPU.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+const concurrentId = 'getTopNodeByCpu';
+
+export function getTopNodesByCpu({
+    type = 'any',
+    sortOrder = -1,
+    sortValue = 'CPU',
+    limit = TENANT_OVERVIEW_TABLES_LIMIT,
+    ...params
+}: NodesApiRequestParams) {
+    return createApiRequest({
+        request: window.api.getNodes(
+            {type, sortOrder, sortValue, limit, ...params},
+            {concurrentId},
+        ),
+        actions: FETCH_TOP_NODES_BY_CPU,
+        dataHandler: prepareNodesData,
+    });
+}
+
+export const selectTopNodesByCpu = (state: TopPoolsStateSlice) => state.topNodesByCpu.data;
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+};

package/dist/store/reducers/tenantOverview/topNodesByCpu/types.ts

@@ -0,0 +1,29 @@
+import type {IResponseError} from '../../../../types/api/error';
+import type {ApiRequestAction} from '../../../utils';
+import type {NodesPreparedEntity} from '../../nodes/types';
+import {FETCH_TOP_NODES_BY_CPU, setDataWasNotLoaded} from './topNodesByCpu';
+
+export interface TopNodesByCpuState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: NodesPreparedEntity[];
+    error?: IResponseError;
+}
+
+export interface TopNodesByCpuHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+}
+
+type TopNodesByCpuApiRequestAction = ApiRequestAction<
+    typeof FETCH_TOP_NODES_BY_CPU,
+    TopNodesByCpuHandledResponse,
+    IResponseError
+>;
+
+export type TopNodesByCpuAction =
+    | TopNodesByCpuApiRequestAction
+    | ReturnType<typeof setDataWasNotLoaded>;
+
+export interface TopPoolsStateSlice {
+    topNodesByCpu: TopNodesByCpuState;
+}

package/dist/store/reducers/tenantOverview/topNodesByLoad/topNodesByLoad.ts

@@ -0,0 +1,87 @@
+import type {Reducer} from 'redux';
+
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {createApiRequest, createRequestActionTypes} from '../../../utils';
+import {prepareNodesData} from '../../nodes/utils';
+import type {NodesApiRequestParams} from '../../nodes/types';
+import type {TopNodesByLoadAction, TopNodesByLoadState, TopNodesByLoadStateSlice} from './types';
+
+export const FETCH_TOP_NODES_BY_LOAD = createRequestActionTypes(
+    'topNodesByLoad',
+    'FETCH_TOP_NODES_BY_LOAD',
+);
+const SET_DATA_WAS_NOT_LOADED = 'topNodesByLoad/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+export const topNodesByLoad: Reducer<TopNodesByLoadState, TopNodesByLoadAction> = (
+    state = initialState,
+    action,
+) => {
+    switch (action.type) {
+        case FETCH_TOP_NODES_BY_LOAD.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_TOP_NODES_BY_LOAD.SUCCESS: {
+            return {
+                ...state,
+                data: action.data?.Nodes,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TOP_NODES_BY_LOAD.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+const concurrentId = 'getTopNodesByLoad';
+
+export function getTopNodesByLoad({
+    type = 'any',
+    sortOrder = -1,
+    sortValue = 'LoadAverage',
+    limit = TENANT_OVERVIEW_TABLES_LIMIT,
+    ...params
+}: NodesApiRequestParams) {
+    return createApiRequest({
+        request: window.api.getNodes(
+            {type, sortOrder, sortValue, limit, ...params},
+            {concurrentId},
+        ),
+        actions: FETCH_TOP_NODES_BY_LOAD,
+        dataHandler: prepareNodesData,
+    });
+}
+
+export const selectTopNodesByLoad = (state: TopNodesByLoadStateSlice) => state.topNodesByLoad.data;
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+};

package/dist/store/reducers/tenantOverview/topNodesByLoad/types.ts

@@ -0,0 +1,29 @@
+import type {IResponseError} from '../../../../types/api/error';
+import type {ApiRequestAction} from '../../../utils';
+import type {NodesPreparedEntity} from '../../nodes/types';
+import {FETCH_TOP_NODES_BY_LOAD, setDataWasNotLoaded} from './topNodesByLoad';
+
+export interface TopNodesByLoadState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: NodesPreparedEntity[];
+    error?: IResponseError;
+}
+
+export interface TopNodesByLoadHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+}
+
+type TopNodesByLoadApiRequestAction = ApiRequestAction<
+    typeof FETCH_TOP_NODES_BY_LOAD,
+    TopNodesByLoadHandledResponse,
+    IResponseError
+>;
+
+export type TopNodesByLoadAction =
+    | TopNodesByLoadApiRequestAction
+    | ReturnType<typeof setDataWasNotLoaded>;
+
+export interface TopNodesByLoadStateSlice {
+    topNodesByLoad: TopNodesByLoadState;
+}

package/dist/store/reducers/tenantOverview/topNodesByMemory/topNodesByMemory.ts

@@ -0,0 +1,87 @@
+import type {Reducer} from 'redux';
+
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {createApiRequest, createRequestActionTypes} from '../../../utils';
+import {prepareNodesData} from '../../nodes/utils';
+import type {NodesApiRequestParams} from '../../nodes/types';
+import type {TopNodesByMemoryAction, TopNodesByMemoryState, TopNodesByMemorySlice} from './types';
+
+export const FETCH_TOP_NODES_BY_MEMORY = createRequestActionTypes(
+    'topNodesByMemory',
+    'FETCH_TOP_NODES_BY_MEMORY',
+);
+const SET_DATA_WAS_NOT_LOADED = 'topNodesByMemory/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+export const topNodesByMemory: Reducer<TopNodesByMemoryState, TopNodesByMemoryAction> = (
+    state = initialState,
+    action,
+) => {
+    switch (action.type) {
+        case FETCH_TOP_NODES_BY_MEMORY.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_TOP_NODES_BY_MEMORY.SUCCESS: {
+            return {
+                ...state,
+                data: action.data?.Nodes,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TOP_NODES_BY_MEMORY.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+const concurrentId = 'getTopNodeByMemory';
+
+export function getTopNodesByMemory({
+    type = 'any',
+    sortOrder = -1,
+    sortValue = 'Memory',
+    limit = TENANT_OVERVIEW_TABLES_LIMIT,
+    ...params
+}: NodesApiRequestParams) {
+    return createApiRequest({
+        request: window.api.getNodes(
+            {type, sortOrder, sortValue, limit, ...params},
+            {concurrentId},
+        ),
+        actions: FETCH_TOP_NODES_BY_MEMORY,
+        dataHandler: prepareNodesData,
+    });
+}
+
+export const selectTopNodesByMemory = (state: TopNodesByMemorySlice) => state.topNodesByMemory.data;
+
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+};

package/dist/store/reducers/tenantOverview/topNodesByMemory/types.ts

@@ -0,0 +1,29 @@
+import type {IResponseError} from '../../../../types/api/error';
+import type {ApiRequestAction} from '../../../utils';
+import type {NodesPreparedEntity} from '../../nodes/types';
+import {FETCH_TOP_NODES_BY_MEMORY, setDataWasNotLoaded} from './topNodesByMemory';
+
+export interface TopNodesByMemoryState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: NodesPreparedEntity[];
+    error?: IResponseError;
+}
+
+export interface TopNodesByMemoryHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+}
+
+type TopNodesByMemoryApiRequestAction = ApiRequestAction<
+    typeof FETCH_TOP_NODES_BY_MEMORY,
+    TopNodesByMemoryHandledResponse,
+    IResponseError
+>;
+
+export type TopNodesByMemoryAction =
+    | TopNodesByMemoryApiRequestAction
+    | ReturnType<typeof setDataWasNotLoaded>;
+
+export interface TopNodesByMemorySlice {
+    topNodesByMemory: TopNodesByMemoryState;
+}

package/dist/store/reducers/tenantOverview/topQueries/tenantOverviewTopQueries.ts

@@ -0,0 +1,93 @@
+import type {Reducer} from 'redux';
+
+import '../../../../services/api';
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {parseQueryAPIExecuteResponse} from '../../../../utils/query';
+
+import {createRequestActionTypes, createApiRequest} from '../../../utils';
+import type {TenantOverviewTopQueriesAction, TenantOverviewTopQueriesState} from './types';
+
+export const FETCH_TENANT_OVERVIEW_TOP_QUERIES = createRequestActionTypes(
+    'tenantOverviewTopQueries',
+    'FETCH_TOP_QUERIES',
+);
+const SET_DATA_WAS_NOT_LOADED = 'tenantOverviewTopQueries/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    filters: {},
+};
+
+const getQueryText = (path: string) => {
+    return `
+SELECT
+    CPUTime as CPUTimeUs,
+    QueryText,
+FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+ORDER BY CPUTimeUs DESC
+LIMIT ${TENANT_OVERVIEW_TABLES_LIMIT}
+`;
+};
+
+export const tenantOverviewTopQueries: Reducer<
+    TenantOverviewTopQueriesState,
+    TenantOverviewTopQueriesAction
+> = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_TENANT_OVERVIEW_TOP_QUERIES.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TENANT_OVERVIEW_TOP_QUERIES.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TENANT_OVERVIEW_TOP_QUERIES.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED:
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        default:
+            return state;
+    }
+};
+
+export const fetchTenantOverviewTopQueries = (database: string) =>
+    createApiRequest({
+        request: window.api.sendQuery(
+            {
+                schema: 'modern',
+                query: getQueryText(database),
+                database,
+                action: 'execute-scan',
+            },
+            {
+                concurrentId: 'executeTopQueries',
+            },
+        ),
+        actions: FETCH_TENANT_OVERVIEW_TOP_QUERIES,
+        dataHandler: parseQueryAPIExecuteResponse,
+    });
+
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+}

package/dist/store/reducers/tenantOverview/topQueries/types.ts

@@ -0,0 +1,14 @@
+import type {IQueryResult, QueryErrorResponse} from '../../../../types/store/query';
+import type {ApiRequestAction} from '../../../utils';
+import {FETCH_TENANT_OVERVIEW_TOP_QUERIES, setDataWasNotLoaded} from './tenantOverviewTopQueries';
+
+export interface TenantOverviewTopQueriesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+}
+
+export type TenantOverviewTopQueriesAction =
+    | ApiRequestAction<typeof FETCH_TENANT_OVERVIEW_TOP_QUERIES, IQueryResult, QueryErrorResponse>
+    | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/tenantOverview/topShards/tenantOverviewTopShards.ts

@@ -0,0 +1,103 @@
+import type {Reducer} from 'redux';
+
+import '../../../../services/api';
+import {TENANT_OVERVIEW_TABLES_LIMIT} from '../../../../utils/constants';
+import {parseQueryAPIExecuteResponse} from '../../../../utils/query';
+import {createRequestActionTypes, createApiRequest} from '../../../utils';
+import {TenantOverviewTopShardsAction, TenantOverviewTopShardsState} from './types';
+
+export const FETCH_TENANT_OVERVIEW_TOP_SHARDS = createRequestActionTypes(
+    'tenantOverviewTopShards',
+    'FETCH_TENANT_OVERVIEW_TOP_SHARDS',
+);
+const SET_DATA_WAS_NOT_LOADED = 'tenantOverviewTopShards/SET_DATA_WAS_NOT_LOADED';
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+function createShardQuery(path: string, tenantName?: string) {
+    const pathSelect = tenantName
+        ? `CAST(SUBSTRING(CAST(Path AS String), ${tenantName.length}) AS Utf8) AS Path`
+        : 'Path';
+
+    return `SELECT
+    ${pathSelect},
+    TabletId,
+    CPUCores,
+FROM \`.sys/partition_stats\`
+WHERE
+    Path='${path}'
+    OR Path LIKE '${path}/%'
+ORDER BY CPUCores DESC
+LIMIT ${TENANT_OVERVIEW_TABLES_LIMIT}`;
+}
+
+const queryAction = 'execute-scan';
+
+export const tenantOverviewTopShards: Reducer<
+    TenantOverviewTopShardsState,
+    TenantOverviewTopShardsAction
+> = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_TENANT_OVERVIEW_TOP_SHARDS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TENANT_OVERVIEW_TOP_SHARDS.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TENANT_OVERVIEW_TOP_SHARDS.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED:
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        default:
+            return state;
+    }
+};
+
+export const sendTenantOverviewTopShardsQuery = (database: string, path = '') =>
+    createApiRequest({
+        request: window.api.sendQuery(
+            {
+                schema: 'modern',
+                query: createShardQuery(path, database),
+                database,
+                action: queryAction,
+            },
+            {
+                concurrentId: 'executeTopShards',
+            },
+        ),
+        actions: FETCH_TENANT_OVERVIEW_TOP_SHARDS,
+        dataHandler: parseQueryAPIExecuteResponse,
+    });
+
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+}

package/dist/store/reducers/tenantOverview/topShards/types.ts

@@ -0,0 +1,14 @@
+import type {IQueryResult, QueryErrorResponse} from '../../../../types/store/query';
+import type {ApiRequestAction} from '../../../utils';
+import {FETCH_TENANT_OVERVIEW_TOP_SHARDS, setDataWasNotLoaded} from './tenantOverviewTopShards';
+
+export interface TenantOverviewTopShardsState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+}
+
+export type TenantOverviewTopShardsAction =
+    | ApiRequestAction<typeof FETCH_TENANT_OVERVIEW_TOP_SHARDS, IQueryResult, QueryErrorResponse>
+    | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/tenantOverview/topShards/utils.ts

@@ -0,0 +1,3 @@
+import {generateEvaluator} from '../../../../utils/generateEvaluator';
+
+export const getLoadSeverityForShard = generateEvaluator(60, 80, ['success', 'warning', 'danger']);

package/dist/styles/mixins.scss

@@ -177,6 +177,10 @@
             .data-table__table-wrapper {
                 padding-bottom: 20px;
             }
+
+            &_sticky-head_fixed {
+                overflow: initial;
+            }
         }
     }
 }