ydb-embedded-ui 2.5.0 → 3.0.0

package/dist/store/reducers/schema.ts

@@ -1,7 +1,16 @@
 import {Reducer} from 'redux';
+import {createSelector, Selector} from 'reselect';
 
-import {ISchemaAction, ISchemaData, ISchemaState} from '../../types/store/schema';
+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';
 
@@ -31,22 +40,24 @@ const schema: Reducer<ISchemaState, ISchemaAction> = (state = initialState, acti
             };
         }
         case FETCH_SCHEMA.SUCCESS: {
-            const newData = JSON.parse(JSON.stringify(state.data));
+            const isCurrentSchema =
+                !state.currentSchemaPath || state.currentSchemaPath === action.data.path;
 
-            if (action.data.Path) {
-                newData[action.data.Path] = action.data;
+            const newData = {...state.data, ...action.data.data};
+
+            if (!isCurrentSchema) {
+                return {
+                    ...state,
+                    data: newData,
+                };
             }
 
-            const currentSchema = state.currentSchemaPath
-                ? newData[state.currentSchemaPath]
-                : action.data;
-            const currentSchemaPath = state.currentSchemaPath || action.data.Path;
             return {
                 ...state,
                 error: undefined,
                 data: newData,
-                currentSchema,
-                currentSchemaPath,
+                currentSchema: action.data.currentSchema,
+                currentSchemaPath: action.data.path,
                 loading: false,
                 wasLoaded: true,
             };
@@ -109,9 +120,48 @@ const schema: Reducer<ISchemaState, ISchemaAction> = (state = initialState, acti
 };
 
 export function getSchema({path}: {path: string}) {
+    const request = window.api.getSchema({path});
     return createApiRequest({
-        request: window.api.getSchema({path}),
+        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,
+            };
+        },
     });
 }
 
@@ -153,4 +203,27 @@ export function resetLoadingState() {
     } 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

@@ -34,6 +34,7 @@ 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,
@@ -116,6 +117,12 @@ const storage = (state = initialState, action) => {
                 error: undefined,
             };
         }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
         default:
             return state;
     }
@@ -169,6 +176,12 @@ export function setNodesUptimeFilter(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,

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',
+}

package/dist/types/api/nodes.ts

@@ -0,0 +1,96 @@
+import {EFlag} from './enums';
+import {TPDiskStateInfo} from './pdisk';
+import {TTabletStateInfo} from './tablet';
+
+export interface TNodesInfo {
+    Overall: EFlag;
+    Nodes?: TNodeInfo[];
+
+    /** uint64 */
+    TotalNodes: string;
+    /** uint64 */
+    FoundNodes: string;
+}
+
+interface TNodeInfo {
+    NodeId: number;
+    SystemState: TSystemStateInfo;
+    PDisks?: TPDiskStateInfo[];
+    Tablets?: TTabletStateInfo[];
+}
+
+interface TSystemStateInfo {
+    /** uint64 */
+    StartTime?: string;
+    /** uint64 */
+    ChangeTime?: string;
+    SystemLocation?: TLegacyNodeLocation;
+    /** double */
+    LoadAverage?: number[];
+    NumberOfCpus?: number;
+    SystemState?: EFlag;
+    MessageBusState?: EFlag;
+    GRpcState?: EFlag;
+    NodeId?: number;
+    Count?: number;
+    DataCenterId?: number;
+    DataCenterDescription?: string;
+    DataCenter?: string;
+    RackId?: number;
+    Rack?: string;
+    Host?: string;
+    Version?: string;
+    PoolStats?: TPoolStats[];
+    Endpoints?: TEndpoint[];
+    Roles?: string[];
+    Tenants?: string[];
+    ClusterName?: string;
+    /** uint64 */
+    MemoryUsed?: string;
+    /** uint64 */
+    MemoryLimit?: string;
+    ConfigState?: EConfigState; //default = Consistent
+    /** uint64 */
+    MemoryUsedInAlloc?: string;
+    /** double */
+    MaxDiskUsage?: number;
+    Location?: TNodeLocation;
+}
+
+interface TPoolStats {
+    Name?: string;
+    /** double */
+    Usage?: number;
+    Threads?: number;
+}
+
+interface TEndpoint {
+    Name?: string;
+    Address?: string;
+}
+
+interface TLegacyNodeLocation {
+    DataCenter?: number;
+    Room?: number;
+    Rack?: number;
+    Body?: number;
+}
+
+interface TNodeLocation {
+    // compatibility section -- will be removed in future versions
+    DataCenterNum?: number; // deprecated
+    RoomNum?: number; // deprecated
+    RackNum?: number; // deprecated
+    BodyNum?: number; // deprecated
+    Body?: number; // deprecated
+
+    DataCenter?: string;
+    Module?: string;
+    Rack?: string;
+    Unit?: string;
+}
+
+enum EConfigState {
+    'Consistent' = 'Consistent',
+    'Outdated' = 'Outdated',
+}

package/dist/types/api/pdisk.ts

@@ -0,0 +1,48 @@
+import {EFlag} from './enums';
+
+export interface TPDiskStateInfo {
+    PDiskId?: number;
+    /** uint64 */
+    CreateTime?: string;
+    /** uint64 */
+    ChangeTime?: string;
+    Path?: string;
+    /** uint64 */
+    Guid?: string;
+    /** uint64 */
+    Category?: string;
+    /** uint64 */
+    AvailableSize?: string;
+    /** uint64 */
+    TotalSize?: string;
+    State?: TPDiskState;
+    NodeId?: number;
+    Count?: number;
+    Device?: EFlag;
+    Realtime?: EFlag;
+    StateFlag?: EFlag;
+    Overall?: EFlag;
+    SerialNumber?: string;
+}
+
+export enum TPDiskState {
+    Initial = 'Initial',
+    InitialFormatRead = 'InitialFormatRead',
+    InitialFormatReadError = 'InitialFormatReadError',
+    InitialSysLogRead = 'InitialSysLogRead',
+    InitialSysLogReadError = 'InitialSysLogReadError',
+    InitialSysLogParseError = 'InitialSysLogParseError',
+    InitialCommonLogRead = 'InitialCommonLogRead',
+    InitialCommonLogReadError = 'InitialCommonLogReadError',
+    InitialCommonLogParseError = 'InitialCommonLogParseError',
+    CommonLoggerInitError = 'CommonLoggerInitError',
+    Normal = 'Normal',
+    OpenFileError = 'OpenFileError',
+    ChunkQuotaError = 'ChunkQuotaError',
+    DeviceIoError = 'DeviceIoError',
+
+    Missing = 'Missing',
+    Timeout = 'Timeout',
+    NodeDisconnected = 'NodeDisconnected',
+    Unknown = 'Unknown',
+}

package/dist/types/api/schema.ts

@@ -41,7 +41,7 @@ enum EStatus {
 interface TPathDescription {
     /** info about the path itself */
     Self?: TDirEntry;
-    DomainDescription?: unknown;
+    DomainDescription?: TDomainDescription;
 
     // for directory
     Children?: TDirEntry[];
@@ -85,6 +85,145 @@ export interface TDirEntry {
     Version?: TPathVersion;
 }
 
+interface TDomainDescription {
+    ProcessingParams?: TProcessingParams;
+
+    DomainKey?: TDomainKey;
+
+    StoragePools?: TStoragePool[];
+
+    /** uint64 */
+    PathsInside?: string;
+    /** uint64 */
+    PathsLimit?: string;
+    /** uint64 */
+    ShardsInside?: string;
+    /** uint64 */
+    ShardsLimit?: string;
+
+    ResourcesDomainKey?: TDomainKey;
+
+    DiskSpaceUsage?: TDiskSpaceUsage;
+
+    /** uint64 */
+    PQPartitionsInside?: string;
+    /** uint64 */
+    PQPartitionsLimit?: string;
+
+    DomainState?: TDomainState;
+
+    DeclaredSchemeQuotas?: TSchemeQuotas;
+    DatabaseQuotas?: DatabaseQuotas;
+    SecurityState?: TSecurityState;
+}
+
+interface TDomainKey {
+    /** fixed64 */
+    SchemeShard?: string;
+    /** fixed64 */
+    PathId?: string;
+}
+
+interface TProcessingParams {
+    Version?: number;
+    /** uint64 */
+    PlanResolution?: string;
+    /** fixed64 */
+    Coordinators?: string[];
+    /** uint64 */
+    TimeCastBucketsPerMediator?: string;
+    /** fixed64 */
+    Mediators?: string[];
+    /** fixed64 */
+    SchemeShard?: string;
+    /** fixed64 */
+    Hive?: string;
+    /** fixed64 */
+    SysViewProcessor?: string;
+}
+
+interface TDomainState {
+    DiskQuotaExceeded?: boolean;
+}
+
+interface TDiskSpaceUsage {
+    Tables?: TTables;
+}
+
+interface TTables {
+    /** uint64 */
+    TotalSize?: string;
+    /** uint64 */
+    DataSize?: string;
+    /** uint64 */
+    IndexSize?: string;
+}
+
+interface TStoragePool {
+    Name?: string;
+    Kind?: string;
+}
+
+interface TSchemeQuotas {
+    SchemeQuotas?: TSchemeQuota[];
+}
+
+interface TSchemeQuota {
+    /** double */
+    BucketSize?: number;
+    /** uint64 */
+    BucketSeconds?: string;
+}
+
+interface TSecurityState {
+    PublicKeys?: TPublicKey[];
+    Sids?: TSid[];
+    Audience: string;
+}
+
+interface TPublicKey {
+    /** uint64 */
+    KeyId: string;
+    KeyDataPEM: string;
+    /** uint64 */
+    ExpiresAt: string;
+}
+
+interface TSid {
+    Name: string;
+    Type: SidType;
+
+    Hash: string;
+    Members?: string[];
+}
+
+enum SidType {
+    'UNKNOWN' = 'UNKNOWN',
+    'USER' = 'USER',
+    'GROUP' = 'GROUP',
+}
+
+interface DatabaseQuotas {
+    /** uint64 */
+    // eslint-disable-next-line camelcase
+    data_size_hard_quota: string;
+
+    /** uint64 */
+    // eslint-disable-next-line camelcase
+    data_size_soft_quota: string;
+
+    /** uint64 */
+    // eslint-disable-next-line camelcase
+    data_stream_shards_quota: string;
+
+    /** uint64 */
+    // eslint-disable-next-line camelcase
+    data_stream_reserved_storage_quota: string;
+
+    // eslint-disable-next-line camelcase
+    ttl_min_run_internal_seconds: number;
+}
+
 // FIXME: incomplete
 export interface TTableDescription {
     PartitionConfig?: TPartitionConfig;
@@ -520,8 +659,8 @@ export interface TColumnTableDescription {
 }
 
 interface TColumnTableSchema {
-    Columns: TOlapColumnDescription[];
-    KeyColumnNames: string[];
+    Columns?: TOlapColumnDescription[];
+    KeyColumnNames?: string[];
     Engine?: EColumnTableEngine;
     NextColumnId?: number;
 
@@ -585,7 +724,7 @@ interface TStorageTier {
     Eviction?: TTtl;
 }
 interface TStorageTiering {
-    Tiers: TStorageTier[];
+    Tiers?: TStorageTier[];
 }
 
 enum EUnit {
@@ -601,10 +740,10 @@ interface TColumnTableSharding {
     Version?: string;
 
     /** uint64 */
-    ColumnShards: string[];
+    ColumnShards?: string[];
 
     /** uint64 */
-    AdditionalColumnShards: string[];
+    AdditionalColumnShards?: string[];
 
     UniquePrimaryKey?: boolean;
 
@@ -614,7 +753,7 @@ interface TColumnTableSharding {
 
 interface THashSharding {
     Function?: EHashFunction;
-    Columns: string[];
+    Columns?: string[];
     UniqueShardKey?: boolean;
     ActiveShardsCount?: number;
 }
@@ -637,9 +776,9 @@ export interface TColumnStoreDescription {
     ColumnShardCount?: number;
 
     /** uint64 */
-    ColumnShards: string[];
+    ColumnShards?: string[];
 
-    SchemaPresets: TColumnTableSchemaPreset[];
+    SchemaPresets?: TColumnTableSchemaPreset[];
     StorageConfig?: TColumnStorageConfig;
 
     NextSchemaPresetId?: number;

package/dist/types/api/storage.ts

@@ -1,175 +1,5 @@
-enum EFlag {
-    Grey = 'Grey',
-    Green = 'Green',
-    Yellow = 'Yellow',
-    Orange = 'Orange',
-    Red = 'Red',
-}
-
-export enum TPDiskState {
-    Initial = 'Initial',
-    InitialFormatRead = 'InitialFormatRead',
-    InitialFormatReadError = 'InitialFormatReadError',
-    InitialSysLogRead = 'InitialSysLogRead',
-    InitialSysLogReadError = 'InitialSysLogReadError',
-    InitialSysLogParseError = 'InitialSysLogParseError',
-    InitialCommonLogRead = 'InitialCommonLogRead',
-    InitialCommonLogReadError = 'InitialCommonLogReadError',
-    InitialCommonLogParseError = 'InitialCommonLogParseError',
-    CommonLoggerInitError = 'CommonLoggerInitError',
-    Normal = 'Normal',
-    OpenFileError = 'OpenFileError',
-    ChunkQuotaError = 'ChunkQuotaError',
-    DeviceIoError = 'DeviceIoError',
-
-    Missing = 'Missing',
-    Timeout = 'Timeout',
-    NodeDisconnected = 'NodeDisconnected',
-    Unknown = 'Unknown',
-}
-
-export interface TPDiskStateInfo {
-    PDiskId?: number;
-    /** uint64 */
-    CreateTime?: string;
-    /** uint64 */
-    ChangeTime?: string;
-    Path?: string;
-    /** uint64 */
-    Guid?: string;
-    /** uint64 */
-    Category?: string;
-    /** uint64 */
-    AvailableSize?: string;
-    /** uint64 */
-    TotalSize?: string;
-    State?: TPDiskState;
-    NodeId?: number;
-    Count?: number;
-    Device?: EFlag;
-    Realtime?: EFlag;
-    StateFlag?: EFlag;
-    Overall?: EFlag;
-    SerialNumber?: string;
-}
-
-export enum EVDiskState {
-    Initial = 'Initial',
-    LocalRecoveryError = 'LocalRecoveryError',
-    SyncGuidRecovery = 'SyncGuidRecovery',
-    SyncGuidRecoveryError = 'SyncGuidRecoveryError',
-    OK = 'OK',
-    PDiskError = 'PDiskError',
-}
-
-interface TRank {
-    /**
-     * Rank in percents; 0-100% is good; >100% is bad.
-     * Formula for rank calculation is the following:
-     * Rank = actual_value / max_allowed_value * 100
-     */
-    RankPercent?: number;
-
-    /**
-     * Flag is the Rank transformed to something simple
-     * to understand: Green, Yellow or Red
-     */
-    Flag?: EFlag;
-}
-
-interface TVDiskSatisfactionRank {
-    FreshRank?: TRank;
-    LevelRank?: TRank;
-}
-
-interface TVDiskID {
-    GroupID?: number;
-    GroupGeneration?: number;
-    Ring?: number;
-    Domain?: number;
-    VDisk?: number;
-}
-
-export interface TVSlotId {
-    NodeId?: number;
-    PDiskId?: number;
-    VSlotId?: number;
-}
-
-export interface TVDiskStateInfo {
-    VDiskId?: TVDiskID;
-    /** uint64 */
-    CreateTime?: string;
-    /** uint64 */
-    ChangeTime?: string;
-    PDisk?: TPDiskStateInfo;
-    VDiskSlotId?: number;
-    /** uint64 */
-    Guid?: string;
-    /** uint64 */
-    Kind?: string;
-    NodeId?: number;
-    Count?: number;
-
-    Overall?: EFlag;
-
-    /** Current state of VDisk */
-    VDiskState?: EVDiskState;
-    /** Disk space flags */
-    DiskSpace?: EFlag;
-    /** Compaction satisfaction rank */
-    SatisfactionRank?: TVDiskSatisfactionRank;
-    /** Is VDisk replicated? (i.e. contains all blobs it must have) */
-    Replicated?: boolean;
-    /** Does this VDisk has any yet unreplicated phantom-like blobs? */
-    UnreplicatedPhantoms?: boolean;
-    /** The same for the non-phantom-like blobs. */
-    UnreplicatedNonPhantoms?: boolean;
-    /**
-     * uint64
-     * How many unsynced VDisks from current BlobStorage group we see
-     */
-    UnsyncedVDisks?: string;
-    /**
-     * uint64
-     * How much this VDisk have allocated on corresponding PDisk
-     */
-    AllocatedSize?: string;
-    /**
-     * uint64
-     * How much space is available for VDisk corresponding to PDisk's hard space limits
-     */
-    AvailableSize?: string;
-    /** Does this disk has some unreadable but not yet restored blobs? */
-    HasUnreadableBlobs?: boolean;
-    /** fixed64 */
-    IncarnationGuid?: string;
-    DonorMode?: boolean;
-    /**
-     * fixed64
-     * VDisk actor instance guid
-     */
-    InstanceGuid?: string;
-    // in reality it is `Donors: TVDiskStateInfo[] | TVSlotId[]`, but this way it is more error-proof
-    Donors?: Array<TVDiskStateInfo | TVSlotId>;
-
-    /** VDisk (Skeleton) Front Queue Status */
-    FrontQueues?: EFlag;
-
-    /** VDisk storage pool label */
-    StoragePoolName?: string;
-
-    /**
-     * uint64
-     * Read bytes per second from PDisk for TEvVGet blobs only
-     */
-    ReadThroughput?: string;
-    /**
-     * uint64
-     * Write bytes per second to PDisk for TEvVPut blobs and replication bytes only
-     */
-    WriteThroughput?: string;
-}
+import {EFlag} from './enums';
+import {TVDiskStateInfo} from './vdisk';
 
 export interface TBSGroupStateInfo {
     GroupID?: number;
@@ -214,7 +44,7 @@ interface THiveStorageGroupStats {
     AvailableSize?: string;
 }
 
-export interface TStoragePoolInfo {
+interface TStoragePoolInfo {
     Overall?: EFlag;
     Name?: string;
     Kind?: string;