ydb-embedded-ui 4.19.3 → 4.20.0

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;
+            }
         }
     }
 }

package/dist/types/additionalProps.ts

@@ -26,6 +26,8 @@ export interface AdditionalTenantsProps {
 
 export type NodeAddress = Pick<TSystemStateInfo, 'Host' | 'Endpoints' | 'NodeId'>;
 
+export type GetNodeRefFunc = (node?: NodeAddress) => string | null;
+
 export interface AdditionalNodesProps extends Record<string, unknown> {
-    getNodeRef?: (node?: NodeAddress) => string | null;
+    getNodeRef?: GetNodeRefFunc;
 }

package/dist/types/api/compute.ts

@@ -20,7 +20,7 @@ export interface TComputeInfo {
     Nodes?: TComputeNodeInfo[]; // v2
 }
 
-interface TComputeTenantInfo {
+export interface TComputeTenantInfo {
     Overall: EFlag;
     Name: string;
     Nodes?: TComputeNodeInfo[];

package/dist/types/react-json-inspector.d.ts

@@ -0,0 +1,21 @@
+declare module 'react-json-inspector' {
+    // This typing is sufficient for current use cases, but some types are incompelete
+    class JSONTree extends React.Component<{
+        data?: object;
+        search?: boolean;
+        searchOptions?: {
+            debounceTime?: number;
+        };
+        onClick?: ({path: string, key: string, value: object}) => void;
+        validateQuery?: (query: string) => boolean;
+        isExpanded?: (keypath: string) => boolean;
+        filterOptions?: {
+            cacheResults?: bool;
+            ignoreCase?: bool;
+        };
+        query?: string;
+        verboseShowOriginal?: boolean;
+        className?: string;
+    }> {}
+    export default JSONTree;
+}

package/dist/utils/diagnostics.ts

@@ -0,0 +1,11 @@
+import {ValueOf} from '../types/common';
+
+export const TOP_SHARDS_SORT_VALUES = {
+    CPUCores: 'CPUCores',
+    DataSize: 'DataSize',
+} as const;
+
+export type TopShardsSortValue = ValueOf<typeof TOP_SHARDS_SORT_VALUES>;
+
+export const isSortableTopShardsProperty = (value: string): value is TopShardsSortValue =>
+    Object.values(TOP_SHARDS_SORT_VALUES).includes(value as TopShardsSortValue);

package/dist/utils/generateEvaluator.ts

@@ -0,0 +1,21 @@
+export const generateEvaluator =
+    <OkLevel extends string, WarnLevel extends string, CritLevel extends string>(
+        warn: number,
+        crit: number,
+        levels: [OkLevel, WarnLevel, CritLevel],
+    ) =>
+    (value: number) => {
+        if (0 <= value && value < warn) {
+            return levels[0];
+        }
+
+        if (warn <= value && value < crit) {
+            return levels[1];
+        }
+
+        if (crit <= value) {
+            return levels[2];
+        }
+
+        return undefined;
+    };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-embedded-ui",
-  "version": "4.19.3",
+  "version": "4.20.0",
   "files": [
     "dist"
   ],