fix(Nodes): support v2 compute (#476)

Author: artemmufazalov

src/containers/Nodes/Nodes.tsx

@@ -71,7 +71,7 @@ export const Nodes = ({path, type, additionalNodesInfo = {}}: NodesProps) => {
         // For not DB entities we always use /compute endpoint instead of /nodes
         // since /nodes can return data only for tenants
         if (path && (!useNodesEndpoint || !isDatabaseEntityType(type))) {
-            dispatch(getComputeNodes(path));
+            dispatch(getComputeNodes({path}));
         } else {
             dispatch(getNodes({tenant: path}));
         }

src/services/api.ts

@@ -28,7 +28,7 @@ import type {DescribeTopicResult} from '../types/api/topic';
 import type {TEvPDiskStateResponse} from '../types/api/pdisk';
 import type {TEvVDiskStateResponse} from '../types/api/vdisk';
 import type {TUserToken} from '../types/api/whoami';
-import type {NodesApiRequestParams} from '../store/reducers/nodes/types';
+import type {ComputeApiRequestParams, NodesApiRequestParams} from '../store/reducers/nodes/types';
 import type {StorageApiRequestParams} from '../store/reducers/storage/types';
 
 import {backend as BACKEND} from '../store';
@@ -82,25 +82,24 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
         });
     }
     getNodes(
-        {tenant, visibleEntities, storage, type = 'any', tablets = true}: NodesApiRequestParams,
+        {visibleEntities, type = 'any', tablets = true, ...params}: NodesApiRequestParams,
         {concurrentId}: AxiosOptions = {},
     ) {
         return this.get<TNodesInfo>(
             this.getPath('/viewer/json/nodes?enums=true'),
             {
-                tenant,
                 with: visibleEntities,
-                storage,
                 type,
                 tablets,
+                ...params,
             },
             {
                 concurrentId,
             },
         );
     }
-    getCompute(path: string) {
-        return this.get<TComputeInfo>(this.getPath('/viewer/json/compute?enums=true'), {path});
+    getCompute(params: ComputeApiRequestParams) {
+        return this.get<TComputeInfo>(this.getPath('/viewer/json/compute?enums=true'), params);
     }
     getStorageInfo(
         {tenant, visibleEntities, nodeId}: StorageApiRequestParams,

src/store/reducers/nodes/nodes.ts

@@ -2,10 +2,16 @@ import type {Reducer} from 'redux';
 
 import '../../../services/api';
 import {NodesUptimeFilterValues} from '../../../utils/nodes';
+import {EVersion} from '../../../types/api/compute';
 
 import {createRequestActionTypes, createApiRequest} from '../../utils';
 
-import type {NodesAction, NodesApiRequestParams, NodesState} from './types';
+import type {
+    ComputeApiRequestParams,
+    NodesAction,
+    NodesApiRequestParams,
+    NodesState,
+} from './types';
 import {prepareComputeNodesData, prepareNodesData} from './utils';
 
 export const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
@@ -80,17 +86,20 @@ const nodes: Reducer<NodesState, NodesAction> = (state = initialState, action) =
     }
 };
 
-export function getNodes({tenant, visibleEntities, type = 'any'}: NodesApiRequestParams) {
+export function getNodes({type = 'any', ...params}: NodesApiRequestParams) {
     return createApiRequest({
-        request: window.api.getNodes({tenant, visibleEntities, type}),
+        request: window.api.getNodes({
+            type,
+            ...params,
+        }),
         actions: FETCH_NODES,
         dataHandler: prepareNodesData,
     });
 }
 
-export function getComputeNodes(path: string) {
+export function getComputeNodes({version = EVersion.v2, ...params}: ComputeApiRequestParams) {
     return createApiRequest({
-        request: window.api.getCompute(path),
+        request: window.api.getCompute({version, ...params}),
         actions: FETCH_NODES,
         dataHandler: prepareComputeNodesData,
     });

src/store/reducers/nodes/types.ts

@@ -1,6 +1,9 @@
 import type {IResponseError} from '../../../types/api/error';
 import type {TEndpoint, TPoolStats} from '../../../types/api/nodes';
-import type {TTabletStateInfo as TComputeTabletStateInfo} from '../../../types/api/compute';
+import type {
+    EVersion,
+    TTabletStateInfo as TComputeTabletStateInfo,
+} from '../../../types/api/compute';
 import type {TTabletStateInfo as TFullTabletStateInfo} from '../../../types/api/tablet';
 import type {EFlag} from '../../../types/api/enums';
 import type {ApiRequestAction} from '../../utils';
@@ -46,17 +49,33 @@ export interface NodesState {
 
 export type NodeType = 'static' | 'dynamic' | 'any';
 
-export interface NodesApiRequestParams {
+interface RequestParams {
+    filter?: string; // NodeId or Host
+    uptime?: number; // return nodes with less uptime in seconds
+    problems_only?: boolean; // return nodes with SystemState !== EFlag.Green
+    sort?: string; // Sort by one of ESort params (may differ for /nodes and /compute)
+
+    offser?: number;
+    limit?: number;
+}
+
+export interface NodesApiRequestParams extends RequestParams {
     tenant?: string;
     type?: NodeType;
-    visibleEntities?: VisibleEntities;
+    visibleEntities?: VisibleEntities; // "with" param
     storage?: boolean;
     tablets?: boolean;
 }
 
+export interface ComputeApiRequestParams extends RequestParams {
+    path: string;
+    version?: EVersion; // only v2 works with filters
+}
+
 export interface NodesHandledResponse {
     Nodes?: NodesPreparedEntity[];
     TotalNodes: number;
+    FoundNodes?: number;
 }
 
 type NodesApiRequestAction = ApiRequestAction<

src/store/reducers/nodes/utils.ts

@@ -1,28 +1,40 @@
-import type {TComputeInfo} from '../../../types/api/compute';
+import type {TComputeInfo, TComputeNodeInfo} from '../../../types/api/compute';
 import type {TNodesInfo} from '../../../types/api/nodes';
 import {calcUptime} from '../../../utils';
 
 import type {NodesHandledResponse, NodesPreparedEntity} from './types';
 
+const prepareComputeNode = (node: TComputeNodeInfo, tenantName?: string) => {
+    return {
+        ...node,
+        // v2 response has tenant name, v1 - doesn't
+        TenantName: node.Tenant ?? tenantName,
+        SystemState: node?.Overall,
+        Uptime: calcUptime(node?.StartTime),
+    };
+};
+
 export const prepareComputeNodesData = (data: TComputeInfo): NodesHandledResponse => {
     const preparedNodes: NodesPreparedEntity[] = [];
 
-    if (data.Tenants) {
+    // First try to parse v2 response in case backend supports it
+    // Else parse v1 response
+    if (data.Nodes) {
+        data.Nodes.forEach((node) => {
+            preparedNodes.push(prepareComputeNode(node));
+        });
+    } else if (data.Tenants) {
         for (const tenant of data.Tenants) {
             tenant.Nodes?.forEach((node) => {
-                preparedNodes.push({
-                    ...node,
-                    TenantName: tenant.Name,
-                    SystemState: node?.Overall,
-                    Uptime: calcUptime(node?.StartTime),
-                });
+                preparedNodes.push(prepareComputeNode(node, tenant.Name));
             });
         }
     }
 
     return {
         Nodes: preparedNodes,
-        TotalNodes: preparedNodes.length,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
     };
 };
 
@@ -41,6 +53,7 @@ export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
 
     return {
         Nodes: preparedNodes,
-        TotalNodes: Number(data.TotalNodes) ?? preparedNodes.length,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
     };
 };

src/types/api/compute.ts

@@ -62,18 +62,18 @@ export interface TTabletStateInfo {
 }
 
 export enum EVersion {
-    v1,
-    v2, // only this versions works with sorting
+    v1 = 'v1',
+    v2 = 'v2', // only this versions works with sorting
 }
 
 export enum ESort {
-    NodeId,
-    Host,
-    DC,
-    Rack,
-    Version,
-    Uptime,
-    Memory,
-    CPU,
-    LoadAverage,
+    NodeId = 'NodeId',
+    Host = 'Host',
+    DC = 'DC',
+    Rack = 'Rack',
+    Version = 'Version',
+    Uptime = 'Uptime',
+    Memory = 'Memory',
+    CPU = 'CPU',
+    LoadAverage = 'LoadAverage',
 }

src/types/api/netInfo.ts

@@ -42,7 +42,7 @@ interface TNetNodePeerInfo {
 }
 
 enum ENodeType {
-    UnknownNodeType,
-    Static,
-    Dynamic,
+    UnknownNodeType = 'UnknownNodeType',
+    Static = 'Static',
+    Dynamic = 'Dynamic',
 }

src/types/api/nodes.ts

@@ -103,12 +103,13 @@ enum EConfigState {
 }
 
 export enum ESort {
-    NodeId,
-    Host,
-    DC,
-    Version,
-    Uptime,
-    Memory,
-    CPU,
-    LoadAverage,
+    NodeId = 'NodeId',
+    Host = 'Host',
+    DC = 'DC',
+    Rack = 'Rack',
+    Version = 'Version',
+    Uptime = 'Uptime',
+    Memory = 'Memory',
+    CPU = 'CPU',
+    LoadAverage = 'LoadAverage',
 }

src/types/api/schema/shared.ts

@@ -28,9 +28,9 @@ export interface TColumnDescription {
 }
 
 export enum EColumnCodec {
-    ColumnCodecPlain,
-    ColumnCodecLZ4,
-    ColumnCodecZSTD,
+    ColumnCodecPlain = 'ColumnCodecPlain',
+    ColumnCodecLZ4 = 'ColumnCodecLZ4',
+    ColumnCodecZSTD = 'ColumnCodecZSTD',
 }
 
 export enum EUnit {

src/types/api/schema/table.ts

@@ -579,38 +579,38 @@ interface TBackgroundPolicy {
 }
 
 enum EPurpose {
-    SysLog,
-    Log,
-    Data,
-    External,
+    SysLog = 'SysLog',
+    Log = 'Log',
+    Data = 'Data',
+    External = 'External',
 }
 
 enum EFreezeState {
-    Unspecified,
-    Freeze,
-    Unfreeze,
+    Unspecified = 'Unspecified',
+    Freeze = 'Freeze',
+    Unfreeze = 'Unfreeze',
 }
 
 enum EColumnCache {
-    ColumnCacheNone,
-    ColumnCacheOnce,
-    ColumnCacheEver,
+    ColumnCacheNone = 'ColumnCacheNone',
+    ColumnCacheOnce = 'ColumnCacheOnce',
+    ColumnCacheEver = 'ColumnCacheEver',
 }
 
 enum EColumnStorage {
-    ColumnStorage1,
-    ColumnStorage2,
-    ColumnStorage1Ext1,
-    ColumnStorage1Ext2,
-    ColumnStorage2Ext1,
-    ColumnStorage2Ext2,
-    ColumnStorage1Med2Ext2,
-    ColumnStorage2Med2Ext2,
-    ColumnStorageTest_1_2_1k,
+    ColumnStorage1 = 'ColumnStorage1',
+    ColumnStorage2 = 'ColumnStorage2',
+    ColumnStorage1Ext1 = 'ColumnStorage1Ext1',
+    ColumnStorage1Ext2 = 'ColumnStorage1Ext2',
+    ColumnStorage2Ext1 = 'ColumnStorage2Ext1',
+    ColumnStorage2Ext2 = 'ColumnStorage2Ext2',
+    ColumnStorage1Med2Ext2 = 'ColumnStorage1Med2Ext2',
+    ColumnStorage2Med2Ext2 = 'ColumnStorage2Med2Ext2',
+    ColumnStorageTest_1_2_1k = 'ColumnStorageTest_1_2_1k',
 }
 
 enum ECompactionStrategy {
-    CompactionStrategyUnset,
-    CompactionStrategyGenerational,
-    CompactionStrategySharded,
+    CompactionStrategyUnset = 'CompactionStrategyUnset',
+    CompactionStrategyGenerational = 'CompactionStrategyGenerational',
+    CompactionStrategySharded = 'CompactionStrategySharded',
 }