ydb-embedded-ui 0.1.0

package/dist/store/reducers/shardsWorkload.js

@@ -0,0 +1,75 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const SEND_SHARD_QUERY = createRequestActionTypes('query', 'SEND_SHARD_QUERY');
+const SET_SHARD_QUERY_OPTIONS = createRequestActionTypes('query', 'SET_SHARD_QUERY_OPTIONS');
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+function createShardQuery(path) {
+    return `SELECT Path, TabletId, CPUCores FROM \`.sys/partition_stats\` WHERE Path='${path}' OR Path LIKE '${path}/%' ORDER BY CPUCores DESC LIMIT 20`;
+}
+
+const queryAction = 'execute-scan';
+
+const shardsWorkload = (state = initialState, action) => {
+    switch (action.type) {
+        case SEND_SHARD_QUERY.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case SEND_SHARD_QUERY.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case SEND_SHARD_QUERY.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_SHARD_QUERY_OPTIONS:
+            return {
+                ...state,
+                ...action.data,
+            };
+        default:
+            return state;
+    }
+};
+
+export const sendShardQuery = ({database, path = ''}) => {
+    return createApiRequest({
+        request: window.api.sendQuery(createShardQuery(path), database, queryAction),
+        actions: SEND_SHARD_QUERY,
+        dataHandler: (result) => {
+            if (result && typeof result === 'string') {
+                throw 'Unexpected token in JSON.';
+            }
+
+            return result;
+        },
+    });
+};
+
+export function setShardQueryOptions(options) {
+    return {
+        type: SET_SHARD_QUERY_OPTIONS,
+        data: options,
+    };
+}
+
+export default shardsWorkload;

package/dist/store/reducers/storage.js

@@ -0,0 +1,280 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import _ from 'lodash';
+import {createSelector} from 'reselect';
+import {calcUptime} from '../../utils';
+
+export const VisibleEntities = {
+    All: 'All',
+    Missing: 'Missing',
+    Space: 'Space',
+};
+
+export const StorageTypes = {
+    groups: 'Groups',
+    nodes: 'Nodes',
+};
+
+const FETCH_STORAGE = createRequestActionTypes('storage', 'FETCH_STORAGE');
+const SET_INITIAL = 'storage/SET_INITIAL';
+const SET_FILTER = 'storage/SET_FILTER';
+const SET_VISIBLE_GROUPS = 'storage/SET_VISIBLE_GROUPS';
+const SET_STORAGE_TYPE = 'storage/SET_STORAGE_TYPE';
+
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+    filter: '',
+    visible: VisibleEntities.Missing,
+    type: StorageTypes.groups,
+};
+
+const storage = function z(state = initialState, action) {
+    switch (action.type) {
+        case FETCH_STORAGE.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_STORAGE.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_STORAGE.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_INITIAL: {
+            return {
+                ...initialState,
+            };
+        }
+        case SET_FILTER: {
+            return {
+                ...state,
+                filter: action.data,
+            };
+        }
+        case SET_VISIBLE_GROUPS: {
+            return {
+                ...state,
+                visible: action.data,
+            };
+        }
+        case SET_STORAGE_TYPE: {
+            return {
+                ...state,
+                type: action.data,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function setInitialState() {
+    return {
+        type: SET_INITIAL,
+    };
+}
+
+export function getStorageInfo({tenant, filter, nodeId, type}) {
+    return createApiRequest({
+        request: window.api.getStorageInfo({tenant, filter, nodeId, type}),
+        actions: FETCH_STORAGE,
+    });
+}
+
+export function setStorageType(value) {
+    return {
+        type: SET_STORAGE_TYPE,
+        data: value,
+    };
+}
+
+export function setStorageFilter(value) {
+    return {
+        type: SET_FILTER,
+        data: value,
+    };
+}
+export function setVisibleEntities(value) {
+    return {
+        type: SET_VISIBLE_GROUPS,
+        data: value,
+    };
+}
+
+export const getStoragePools = (state) => state.storage.data?.StoragePools;
+export const getStorageNodes = (state) => state.storage.data?.Nodes;
+export const getStorageFilter = (state) => state.storage.filter;
+export const getVisibleEntities = (state) => state.storage.visible;
+export const getStorageType = (state) => state.storage.type;
+export const getNodesObject = (state) =>
+    _.reduce(
+        state.nodesList?.data,
+        (acc, el) => {
+            acc[el.NodeId] = el.Host;
+            return acc;
+        },
+        {},
+    );
+
+const FLAGS_POINTS = {
+    Green: 1,
+    Yellow: 100,
+    Orange: 10_000,
+    Red: 1_000_000,
+};
+export const getFlatListStorageGroups = createSelector([getStoragePools], (storagePools) => {
+    return _.reduce(
+        storagePools,
+        (acc, pool) => {
+            const groups = _.reduce(
+                pool.Groups,
+                (acc, group) => {
+                    const missing = _.filter(group.VDisks, (v) => {
+                        return !v.Replicated || v.PDisk.State !== 'Normal' || v.VDiskState !== 'OK';
+                    }).length;
+
+                    const UsedSpaceFlag = _.reduce(
+                        group.VDisks,
+                        (acc, v) => {
+                            if (v.DiskSpace) {
+                                acc += FLAGS_POINTS[v.DiskSpace];
+                            }
+                            return acc;
+                        },
+                        0,
+                    );
+
+                    const usedSpaceBytes = _.reduce(
+                        group.VDisks,
+                        (acc, vDisk) => {
+                            return acc + (Number(vDisk.AllocatedSize) || 0);
+                        },
+                        0,
+                    );
+                    const limitSizeBytes = _.reduce(
+                        group.VDisks,
+                        (acc, vDisk) => {
+                            return (
+                                acc +
+                                (Number(vDisk.AvailableSize) ||
+                                    Number(vDisk.PDisk?.AvailableSize) ||
+                                    0) +
+                                (Number(vDisk.AllocatedSize) || 0)
+                            );
+                        },
+                        0,
+                    );
+                    const readSpeedBytesPerSec = _.reduce(
+                        group.VDisks,
+                        (acc, vDisk) => {
+                            return acc + (Number(vDisk.ReadThroughput) || 0);
+                        },
+                        0,
+                    );
+                    const writeSpeedBytesPerSec = _.reduce(
+                        group.VDisks,
+                        (acc, vDisk) => {
+                            return acc + (Number(vDisk.WriteThroughput) || 0);
+                        },
+                        0,
+                    );
+                    return [
+                        ...acc,
+                        {
+                            ...group,
+                            Read: readSpeedBytesPerSec,
+                            Write: writeSpeedBytesPerSec,
+                            PoolName: pool.Name,
+                            Used: usedSpaceBytes,
+                            Limit: limitSizeBytes,
+                            Missing: missing,
+                            UsedSpaceFlag,
+                        },
+                    ];
+                },
+                [],
+            );
+            return [...acc, ...groups];
+        },
+        [],
+    );
+});
+
+export const getFlatListStorageNodes = createSelector([getStorageNodes], (storageNodes) => {
+    return _.map(storageNodes, (node) => {
+        const systemState = node.SystemState ?? {};
+        const missing = _.filter(node.PDisks, (p) => {
+            return p.State !== 'Normal';
+        }).length;
+        return {
+            NodeId: node.NodeId,
+            FQDN: systemState.Host,
+            uptime: calcUptime(systemState.StartTime),
+            StartTime: systemState.StartTime,
+            PDisks: node.PDisks,
+            Missing: missing,
+        };
+    });
+});
+
+export const getFlatListStorage = createSelector(
+    [getStorageType, getFlatListStorageGroups, getFlatListStorageNodes],
+    (storageType, groupsList, nodesList) => {
+        if (storageType === StorageTypes.groups) {
+            return groupsList;
+        }
+        return nodesList;
+    },
+);
+
+export const getVisibleEntitiesList = createSelector(
+    [getVisibleEntities, getFlatListStorage],
+    (visibleGroups, storageList) => {
+        if (visibleGroups === VisibleEntities.All) {
+            return storageList;
+        } else if (visibleGroups === VisibleEntities.Missing) {
+            return _.filter(storageList, (g) => g.Missing > 0);
+        } else {
+            return _.filter(storageList, (g) => g.UsedSpaceFlag > 100);
+        }
+    },
+);
+
+export const getFilteredEntities = createSelector(
+    [getStorageFilter, getStorageType, getVisibleEntitiesList],
+    (filter, type, entities) => {
+        const cleanedFilter = filter.trim().toLowerCase();
+        if (!cleanedFilter) {
+            return entities;
+        } else {
+            return _.filter(entities, (e) => {
+                if (type === StorageTypes.groups) {
+                    return (
+                        e.PoolName.toLowerCase().includes(cleanedFilter) ||
+                        e.GroupID?.toString().includes(cleanedFilter)
+                    );
+                }
+                return (
+                    e.NodeId.toString().includes(cleanedFilter) ||
+                    e.FQDN.toLowerCase().includes(cleanedFilter)
+                );
+            });
+        }
+    },
+);
+
+export default storage;

package/dist/store/reducers/tablet.js

@@ -0,0 +1,94 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import _ from 'lodash';
+
+const FETCH_TABLET = createRequestActionTypes('TABLET', 'FETCH_TABLET');
+const FETCH_TABLET_DESCRIBE = createRequestActionTypes('TABLET', 'FETCH_TABLET_DESCRIBE');
+
+const tablet = (state = {loading: false, tenantPath: '-'}, action) => {
+    switch (action.type) {
+        case FETCH_TABLET.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_TABLET.SUCCESS: {
+            const {tablet, history} = action.data;
+            const {TabletId: id} = tablet;
+            return {
+                ...state,
+                id,
+                data: tablet,
+                history,
+                loading: false,
+                error: undefined,
+            };
+        }
+        case FETCH_TABLET.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case FETCH_TABLET_DESCRIBE.SUCCESS: {
+            const {tenantPath} = action.data;
+
+            return {
+                ...state,
+                tenantPath,
+                error: undefined,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const getTablet = (id) => {
+    return createApiRequest({
+        request: Promise.all([window.api.getTablet({id}), window.api.getTabletHistory({id})]),
+        actions: FETCH_TABLET,
+        dataHandler: ([tabletData, history]) => {
+            const historyData = Object.keys(history).reduce((list, nodeId) => {
+                const tabletInfo = history[nodeId]?.TabletStateInfo;
+                if (tabletInfo && tabletInfo.length) {
+                    const leaderTablet =
+                        _.find(tabletInfo, (t) => t.Master || t.Leader) || tabletInfo[0];
+                    const {ChangeTime, Generation, State, Master, SlaveId, Leader, FollowerId} =
+                        leaderTablet;
+                    list.push({
+                        nodeId,
+                        generation: Generation,
+                        changeTime: ChangeTime,
+                        state: State,
+                        leader: Master || Leader,
+                        followerId: SlaveId || FollowerId,
+                    });
+                }
+                return list;
+            }, []);
+
+            const {TabletStateInfo = []} = tabletData;
+            const [tablet = {}] = TabletStateInfo;
+
+            return {tablet, history: historyData};
+        },
+    });
+};
+
+export const getTabletDescribe = (TenantId) => {
+    return createApiRequest({
+        request: window.api.getTabletDescribe(TenantId),
+        actions: FETCH_TABLET_DESCRIBE,
+        dataHandler: (tabletDescribe) => {
+            const {SchemeShard, PathId} = TenantId;
+            const tenantPath = tabletDescribe.Path || `${SchemeShard}:${PathId}`;
+
+            return {tenantPath};
+        },
+    });
+};
+
+export default tablet;

package/dist/store/reducers/tablets.js

@@ -0,0 +1,90 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import {AUTO_RELOAD_INTERVAL} from '../../utils/constants';
+
+const FETCH_TABLETS = createRequestActionTypes('tablets', 'FETCH_TABLETS');
+
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+    stateFilter: [],
+    typeFilter: [],
+};
+
+const tablets = function z(state = initialState, action) {
+    switch (action.type) {
+        case FETCH_TABLETS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                requestTime: new Date().getTime(),
+            };
+        }
+        case FETCH_TABLETS.SUCCESS: {
+            const timeout = new Date().getTime() - state.requestTime;
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                timeoutForRequest: timeout > AUTO_RELOAD_INTERVAL ? timeout : AUTO_RELOAD_INTERVAL,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_TABLETS.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case 'CLEAR_WAS_LOADING_TABLETS': {
+            return {
+                ...state,
+                wasLoaded: false,
+                loading: true,
+            };
+        }
+        case 'SET_STATE_FILTER': {
+            return {
+                ...state,
+                stateFilter: action.data,
+            };
+        }
+        case 'SET_TYPE_FILTER': {
+            return {
+                ...state,
+                typeFilter: action.data,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const setStateFilter = (stateFilter) => {
+    return {
+        type: 'SET_STATE_FILTER',
+        data: stateFilter,
+    };
+};
+
+export const setTypeFilter = (typeFilter) => {
+    return {
+        type: 'SET_TYPE_FILTER',
+        data: typeFilter,
+    };
+};
+
+export const clearWasLoadingFlag = () => ({
+    type: 'CLEAR_WAS_LOADING_TABLETS',
+});
+
+export function getTabletsInfo(data) {
+    return createApiRequest({
+        request: window.api.getTabletsInfo(data),
+        actions: FETCH_TABLETS,
+    });
+}
+
+export default tablets;

package/dist/store/reducers/tabletsFilters.js

@@ -0,0 +1,126 @@
+import {createSelector} from 'reselect';
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import {AUTO_RELOAD_INTERVAL} from '../../utils/constants';
+
+const FETCH_TABLETS_FILTERS = createRequestActionTypes('tabletsFilters', 'FETCH_TABLETS_FILTERS');
+
+const initialState = {
+    data: undefined,
+    loading: true,
+    wasLoaded: false,
+    stateFilter: [],
+    typeFilter: [],
+};
+
+const tabletsFilters = function (state = initialState, action) {
+    switch (action.type) {
+        case FETCH_TABLETS_FILTERS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                requestTime: new Date().getTime(),
+            };
+        }
+        case FETCH_TABLETS_FILTERS.SUCCESS: {
+            const timeout = new Date().getTime() - state.requestTime;
+            const [tabletsData, nodes] = action.data;
+            return {
+                ...state,
+                tabletsData,
+                nodes,
+                loading: false,
+                wasLoaded: true,
+                timeoutForRequest: timeout > AUTO_RELOAD_INTERVAL ? timeout : AUTO_RELOAD_INTERVAL,
+                error: undefined,
+            };
+        }
+
+        // The error with large uri is handled by GenericAPI
+        case FETCH_TABLETS_FILTERS.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Request-URI Too Large. Please reload the page',
+                loading: false,
+            };
+        }
+        case 'CLEAR_WAS_LOADING_TABLETS': {
+            const {stateFilter, typeFilter} = state;
+            return {
+                ...initialState,
+                stateFilter,
+                typeFilter,
+            };
+        }
+        case 'SET_STATE_FILTER': {
+            return {
+                ...state,
+                stateFilter: action.data,
+            };
+        }
+        case 'SET_TYPE_FILTER': {
+            return {
+                ...state,
+                typeFilter: action.data,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const clearWasLoadingFlag = () => ({
+    type: 'CLEAR_WAS_LOADING_TABLETS',
+});
+
+export const setStateFilter = (stateFilter) => {
+    return {
+        type: 'SET_STATE_FILTER',
+        data: stateFilter,
+    };
+};
+
+export const setTypeFilter = (typeFilter) => {
+    return {
+        type: 'SET_TYPE_FILTER',
+        data: typeFilter,
+    };
+};
+
+export function getTabletsInfo(data) {
+    return createApiRequest({
+        request: Promise.all([window.api.getTabletsInfo(data), window.api.getNodesList()]),
+        actions: FETCH_TABLETS_FILTERS,
+    });
+}
+
+export const getTablets = (state) => {
+    const {tabletsData} = state.tabletsFilters;
+    return tabletsData?.TabletStateInfo || [];
+};
+
+export const getFilteredTablets = createSelector(
+    [
+        getTablets,
+        (state) => state.tabletsFilters.stateFilter,
+        (state) => state.tabletsFilters.typeFilter,
+    ],
+    (tablets, stateFilter, typeFilter) => {
+        let filteredTablets = tablets;
+
+        if (typeFilter.length > 0) {
+            filteredTablets = filteredTablets.filter((tblt) =>
+                typeFilter.some((filter) => tblt.Type === filter),
+            );
+        }
+        if (stateFilter.length > 0) {
+            filteredTablets = filteredTablets.filter((tblt) =>
+                stateFilter.some((filter) => tblt.State === filter),
+            );
+        }
+
+        return filteredTablets;
+    },
+);
+
+export default tabletsFilters;