ydb-embedded-ui 2.4.4 → 2.6.0

package/dist/types/api/vdisk.ts

@@ -0,0 +1,120 @@
+import {EFlag} from './enums';
+import {TPDiskStateInfo} from './pdisk';
+
+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;
+}
+
+export interface TVSlotId {
+    NodeId?: number;
+    PDiskId?: number;
+    VSlotId?: number;
+}
+
+interface TVDiskSatisfactionRank {
+    FreshRank?: TRank;
+    LevelRank?: TRank;
+}
+
+interface TVDiskID {
+    GroupID?: number;
+    GroupGeneration?: number;
+    Ring?: number;
+    Domain?: number;
+    VDisk?: number;
+}
+
+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;
+}
+
+enum EVDiskState {
+    Initial = 'Initial',
+    LocalRecoveryError = 'LocalRecoveryError',
+    SyncGuidRecovery = 'SyncGuidRecovery',
+    SyncGuidRecoveryError = 'SyncGuidRecoveryError',
+    OK = 'OK',
+    PDiskError = 'PDiskError',
+}

package/dist/types/store/describe.ts

@@ -13,14 +13,20 @@ export interface IDescribeState {
     loading: boolean;
     wasLoaded: boolean;
     data: IDescribeData;
-    currentDescribe?: TEvDescribeSchemeResult;
+    currentDescribe?: IDescribeData;
     currentDescribePath?: string;
     error?: IResponseError;
 }
 
+export interface IDescribeHandledResponse {
+    path: string | undefined;
+    data: IDescribeData | undefined;
+    currentDescribe: IDescribeData | undefined;
+}
+
 type IDescribeApiRequestAction = ApiRequestAction<
     typeof FETCH_DESCRIBE,
-    TEvDescribeSchemeResult,
+    IDescribeHandledResponse,
     IResponseError
 >;
 

package/dist/types/store/healthcheck.ts

@@ -1,3 +1,5 @@
+import {ApiRequestAction} from '../../store/utils';
+import {FETCH_HEALTHCHECK, setDataWasNotLoaded} from '../../store/reducers/healthcheckInfo';
 import {IResponseError} from '../api/error';
 import type {HealthCheckAPIResponse, IssueLog} from '../api/healthcheck';
 
@@ -14,6 +16,16 @@ export interface IHealthcheckInfoState {
     error?: IResponseError;
 }
 
+type IHealthCheckApiRequestAction = ApiRequestAction<
+    typeof FETCH_HEALTHCHECK,
+    HealthCheckAPIResponse,
+    IResponseError
+>;
+
+export type IHealthCheckInfoAction =
+    | IHealthCheckApiRequestAction
+    | ReturnType<typeof setDataWasNotLoaded>;
+
 export interface IHealthcheckInfoRootStateSlice {
     healthcheckInfo: IHealthcheckInfoState;
 }

package/dist/types/store/schema.ts

@@ -0,0 +1,52 @@
+import {
+    disableAutorefresh,
+    enableAutorefresh,
+    FETCH_SCHEMA,
+    preloadSchemas,
+    resetLoadingState,
+    setCurrentSchemaPath,
+    setShowPreview,
+} from '../../store/reducers/schema';
+import {ApiRequestAction} from '../../store/utils';
+import {IResponseError} from '../api/error';
+import {TEvDescribeSchemeResult} from '../api/schema';
+
+export type ISchemaData = Record<string, TEvDescribeSchemeResult>;
+
+export interface ISchemaState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data: ISchemaData;
+    currentSchema?: TEvDescribeSchemeResult;
+    currentSchemaPath?: string;
+    autorefresh: boolean;
+    showPreview: boolean;
+    error?: IResponseError;
+}
+
+export interface ISchemaHandledResponse {
+    path: string | undefined;
+    currentSchema: TEvDescribeSchemeResult | undefined;
+    data: ISchemaData | undefined;
+}
+
+type ISchemaApiRequestAction = ApiRequestAction<
+    typeof FETCH_SCHEMA,
+    ISchemaHandledResponse,
+    IResponseError
+>;
+
+export type ISchemaAction =
+    | ISchemaApiRequestAction
+    | (
+          | ReturnType<typeof setCurrentSchemaPath>
+          | ReturnType<typeof enableAutorefresh>
+          | ReturnType<typeof disableAutorefresh>
+          | ReturnType<typeof setShowPreview>
+          | ReturnType<typeof preloadSchemas>
+          | ReturnType<typeof resetLoadingState>
+      );
+
+export interface ISchemaRootStateSlice {
+    schema: ISchemaState;
+}

package/dist/utils/index.js

@@ -79,9 +79,13 @@ export const formatDateTime = (value) => {
     return value > 0 ? new Date(Number(value)).toUTCString() : 'N/A';
 };
 
-export const calcUptime = (milliseconds) => {
+export const calcUptimeInSeconds = (milliseconds) => {
     const currentDate = new Date();
-    return formatUptime((currentDate - Number(milliseconds)) / 1000);
+    return (currentDate - Number(milliseconds)) / 1000;
+};
+
+export const calcUptime = (milliseconds) => {
+    return formatUptime(calcUptimeInSeconds(milliseconds));
 };
 
 // determine how many nodes have status Connected "true"

package/dist/utils/nodes.ts

@@ -0,0 +1,9 @@
+export const NodesUptimeFilterValues = {
+    All: 'All',
+    SmallUptime: 'SmallUptime',
+};
+
+export const NodesUptimeFilterTitles = {
+    [NodesUptimeFilterValues.All]: 'All',
+    [NodesUptimeFilterValues.SmallUptime]: 'Uptime < 1h',
+};

package/dist/utils/pdisk.ts

@@ -1,4 +1,4 @@
-import type {TPDiskStateInfo} from "../types/api/storage";
+import type {TPDiskStateInfo} from '../types/api/pdisk';
 
 // TODO: move to utils or index after converting them to TS
 /**

package/dist/utils/storage.ts

@@ -1,4 +1,4 @@
-import type {TVDiskStateInfo, TVSlotId} from '../types/api/storage';
+import type {TVSlotId, TVDiskStateInfo} from '../types/api/vdisk';
 import type {IStoragePoolGroup} from '../types/store/storage';
 
 export const isFullDonorData = (donor: TVDiskStateInfo | TVSlotId): donor is TVDiskStateInfo =>

package/package.json

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

package/dist/store/reducers/schema.js

@@ -1,148 +0,0 @@
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import '../../services/api';
-
-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 = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_SCHEMA.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_SCHEMA.SUCCESS: {
-            const newData = JSON.parse(JSON.stringify(state.data));
-            newData[action.data.Path] = action.data;
-            const currentSchema = state.currentSchemaPath
-                ? newData[state.currentSchemaPath]
-                : action.data;
-            const currentSchemaPath = state.currentSchemaPath || action.data.Path;
-            return {
-                ...state,
-                error: undefined,
-                data: newData,
-                currentSchema,
-                currentSchemaPath,
-                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}) {
-    return createApiRequest({
-        request: window.api.getSchema({path}),
-        actions: FETCH_SCHEMA,
-    });
-}
-
-export function setCurrentSchemaPath(currentSchemaPath) {
-    return {
-        type: SET_SCHEMA,
-        data: currentSchemaPath,
-    };
-}
-export function enableAutorefresh() {
-    return {
-        type: ENABLE_AUTOREFRESH,
-    };
-}
-export function disableAutorefresh() {
-    return {
-        type: DISABLE_AUTOREFRESH,
-    };
-}
-export function setShowPreview(value) {
-    return {
-        type: SET_SHOW_PREVIEW,
-        data: value,
-    };
-}
-
-// only stores data for paths that are not in the store yet
-// existing paths are ignored
-export function preloadSchemas(data) {
-    return {
-        type: PRELOAD_SCHEMAS,
-        data,
-    };
-}
-
-export function resetLoadingState() {
-    return {
-        type: RESET_LOADING_STATE,
-    };
-}
-
-export default schema;