ydb-embedded-ui 4.9.0 → 4.10.1

package/dist/store/reducers/tenants/utils.ts

@@ -0,0 +1,68 @@
+import type {TTenant} from '../../../types/api/tenant';
+import {isNumeric} from '../../../utils/utils';
+
+const getControlPlaneValue = (tenant: TTenant) => {
+    const parts = tenant.Name.split('/');
+    const defaultValue = parts.length ? parts[parts.length - 1] : '—';
+    const controlPlaneName = tenant.ControlPlane?.name;
+
+    return controlPlaneName ?? defaultValue;
+};
+
+const getTenantBackend = (tenant: TTenant) => {
+    const node = tenant.Nodes ? tenant.Nodes[0] : {};
+    const address =
+        node.Host && node.Endpoints
+            ? node.Endpoints.find((endpoint) => endpoint.Name === 'http-mon')?.Address
+            : undefined;
+    return node.Host ? `${node.Host}${address ? address : ''}` : undefined;
+};
+
+const calculateTenantMetrics = (tenant: TTenant) => {
+    const {CoresUsed, MemoryUsed, StorageAllocatedSize, Metrics = {}} = tenant;
+
+    const cpuFromCores = isNumeric(CoresUsed) ? Number(CoresUsed) * 1_000_000 : undefined;
+    const cpuFromMetrics = isNumeric(Metrics.CPU) ? Number(Metrics.CPU) : undefined;
+
+    const cpu = cpuFromCores ?? cpuFromMetrics ?? 0;
+
+    const rawMemory = MemoryUsed ?? Metrics.Memory;
+    const rawStorage = StorageAllocatedSize ?? Metrics.Storage;
+
+    const memory = isNumeric(rawMemory) ? Number(rawMemory) : 0;
+    const storage = isNumeric(rawStorage) ? Number(rawStorage) : 0;
+
+    return {cpu, memory, storage};
+};
+
+const calculateTenantEntities = (tenant: TTenant) => {
+    const {StorageGroups, NodeIds} = tenant;
+
+    const nodesCount = NodeIds?.length ?? 0;
+    const groupsCount = isNumeric(StorageGroups) ? Number(StorageGroups) : 0;
+
+    return {nodesCount, groupsCount};
+};
+
+export const prepareTenants = (tenants: TTenant[], useNodeAsBackend: boolean) => {
+    return tenants.map((tenant) => {
+        const backend = useNodeAsBackend ? getTenantBackend(tenant) : undefined;
+        const sharedTenantName = tenants.find((item) => item.Id === tenant.ResourceId)?.Name;
+        const controlPlaneName = getControlPlaneValue(tenant);
+        const {cpu, memory, storage} = calculateTenantMetrics(tenant);
+        const {nodesCount, groupsCount} = calculateTenantEntities(tenant);
+
+        return {
+            ...tenant,
+
+            backend,
+            sharedTenantName,
+            controlPlaneName,
+            cpu,
+            memory,
+            storage,
+            nodesCount,
+            groupsCount,
+        };
+    });
+};

package/dist/types/additionalProps.ts

@@ -1,4 +1,7 @@
+import type {ReactNode} from 'react';
+
 import type {InfoViewerItem} from '../components/InfoViewer';
+import type {ETenantType} from './api/tenant';
 import type {VersionToColorMap} from './versions';
 
 export interface AdditionalVersionsProps {
@@ -14,3 +17,8 @@ export interface AdditionalClusterProps {
     info?: InfoViewerItem[];
     links?: ClusterLink[];
 }
+
+export interface AdditionalTenantsProps {
+    prepareTenantBackend?: (backend: string | undefined) => string | undefined;
+    getMonitoringLink?: (name: string, type: ETenantType) => ReactNode;
+}

package/dist/types/api/compute.ts

@@ -4,13 +4,20 @@ import {TMetrics} from './tenant';
 
 /**
  * endpoint: viewer/json/compute
- * 
+ *
  * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ *
+ * response has 2 versions, depending on version param in request
  */
 export interface TComputeInfo {
     Overall: EFlag;
-    Tenants?: TComputeTenantInfo[];
+    Tenants?: TComputeTenantInfo[]; // v1
     Errors?: string[];
+    /** uint64 */
+    TotalNodes: string;
+    /** uint64 */
+    FoundNodes: string;
+    Nodes?: TComputeNodeInfo[]; // v2
 }
 
 interface TComputeTenantInfo {
@@ -43,6 +50,7 @@ export interface TComputeNodeInfo {
     MemoryLimit?: string;
     Metrics: TMetrics;
     Tablets?: TTabletStateInfo[];
+    Tenant?: string; // For v2 response without grouping by tenants
 }
 
 // Tablets in compute nodes
@@ -52,3 +60,20 @@ export interface TTabletStateInfo {
     State: EFlag;
     Count: number;
 }
+
+export enum EVersion {
+    v1,
+    v2, // only this versions works with sorting
+}
+
+export enum ESort {
+    NodeId,
+    Host,
+    DC,
+    Rack,
+    Version,
+    Uptime,
+    Memory,
+    CPU,
+    LoadAverage,
+}

package/dist/types/api/nodes.ts

@@ -5,7 +5,7 @@ import {TVDiskStateInfo} from './vdisk';
 
 /**
  * endpoint: /viewer/json/nodes
- * 
+ *
  * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
  */
 export interface TNodesInfo {
@@ -101,3 +101,14 @@ enum EConfigState {
     'Consistent' = 'Consistent',
     'Outdated' = 'Outdated',
 }
+
+export enum ESort {
+    NodeId,
+    Host,
+    DC,
+    Version,
+    Uptime,
+    Memory,
+    CPU,
+    LoadAverage,
+}

package/dist/types/api/schema/cdcStream.ts

@@ -0,0 +1,32 @@
+import type {TPathID} from './shared';
+
+export interface TCdcStreamDescription {
+    Name?: string;
+    Mode?: ECdcStreamMode;
+    Format?: ECdcStreamFormat;
+    PathId?: TPathID;
+    State?: ECdcStreamState;
+    /** uint64 */
+    SchemaVersion?: string;
+}
+
+enum ECdcStreamMode {
+    ECdcStreamModeInvalid = 'ECdcStreamModeInvalid',
+    ECdcStreamModeKeysOnly = 'ECdcStreamModeKeysOnly',
+    ECdcStreamModeUpdate = 'ECdcStreamModeUpdate',
+    ECdcStreamModeNewImage = 'ECdcStreamModeNewImage',
+    ECdcStreamModeOldImage = 'ECdcStreamModeOldImage',
+    ECdcStreamModeNewAndOldImages = 'ECdcStreamModeNewAndOldImages',
+}
+
+enum ECdcStreamFormat {
+    ECdcStreamFormatInvalid = 'ECdcStreamFormatInvalid',
+    ECdcStreamFormatProto = 'ECdcStreamFormatProto',
+    ECdcStreamFormatJson = 'ECdcStreamFormatJson',
+}
+
+enum ECdcStreamState {
+    ECdcStreamStateInvalid = 'ECdcStreamStateInvalid',
+    ECdcStreamStateReady = 'ECdcStreamStateReady',
+    ECdcStreamStateDisabled = 'ECdcStreamStateDisabled',
+}

package/dist/types/api/schema/columnEntity.ts

@@ -0,0 +1,138 @@
+import type {EColumnCodec, EUnit, TPathID, TStorageSettings, TTypeInfo} from './shared';
+
+export interface TColumnTableDescription {
+    Name?: string;
+
+    Schema?: TColumnTableSchema;
+    TtlSettings?: TColumnDataLifeCycle;
+
+    SchemaPresetId?: number;
+    SchemaPresetName?: string;
+
+    ColumnStorePathId?: TPathID;
+
+    ColumnShardCount?: number;
+    Sharding?: TColumnTableSharding;
+
+    /** uint64 */
+    SchemaPresetVersionAdj?: string;
+    /** uint64 */
+    TtlSettingsPresetVersionAdj?: string;
+
+    StorageConfig?: TColumnStorageConfig;
+}
+
+export interface TColumnStoreDescription {
+    Name?: string;
+    ColumnShardCount?: number;
+
+    /** uint64 */
+    ColumnShards?: string[];
+
+    SchemaPresets?: TColumnTableSchemaPreset[];
+    StorageConfig?: TColumnStorageConfig;
+
+    NextSchemaPresetId?: number;
+    NextTtlSettingsPresetId?: number;
+}
+
+export interface TColumnDataLifeCycle {
+    Enabled?: TTtl;
+    Disabled?: {};
+    Tiering?: TStorageTiering;
+
+    /** uint64 */
+    Version?: string;
+}
+
+interface TColumnStorageConfig {
+    SysLog?: TStorageSettings;
+    Log?: TStorageSettings;
+    Data?: TStorageSettings;
+    DataChannelCount?: number;
+}
+
+interface TStorageTiering {
+    Tiers?: TStorageTier[];
+}
+
+interface TStorageTier {
+    Name?: string;
+    Eviction?: TTtl;
+}
+
+interface TTtl {
+    ColumnName?: string;
+
+    ExpireAfterSeconds?: number;
+
+    /** uint64 */
+    ExpireAfterBytes?: string;
+
+    ColumnUnit?: EUnit;
+}
+
+interface TColumnTableSchema {
+    Columns?: TOlapColumnDescription[];
+    KeyColumnNames?: string[];
+    Engine?: EColumnTableEngine;
+    NextColumnId?: number;
+
+    /** uint64 */
+    Version?: string;
+
+    DefaultCompression?: TCompressionOptions;
+    EnableTiering?: boolean;
+}
+
+interface TColumnTableSchemaPreset {
+    Id?: number;
+    Name?: string;
+    Schema?: TColumnTableSchema;
+}
+
+interface TOlapColumnDescription {
+    Id?: number;
+    Name?: string;
+    Type?: string;
+    TypeId?: number;
+    TypeInfo?: TTypeInfo;
+}
+
+interface TColumnTableSharding {
+    /** uint64 */
+    Version?: string;
+
+    /** uint64 */
+    ColumnShards?: string[];
+
+    /** uint64 */
+    AdditionalColumnShards?: string[];
+
+    UniquePrimaryKey?: boolean;
+
+    RandomSharding?: {};
+    HashSharding?: THashSharding;
+}
+
+interface THashSharding {
+    Function?: EHashFunction;
+    Columns?: string[];
+    UniqueShardKey?: boolean;
+    ActiveShardsCount?: number;
+}
+
+interface TCompressionOptions {
+    CompressionCodec?: EColumnCodec;
+    CompressionLevel?: number;
+}
+
+enum EHashFunction {
+    HASH_FUNCTION_MODULO_N = 'HASH_FUNCTION_MODULO_N',
+    HASH_FUNCTION_CLOUD_LOGS = 'HASH_FUNCTION_CLOUD_LOGS',
+}
+
+enum EColumnTableEngine {
+    COLUMN_ENGINE_NONE = 'COLUMN_ENGINE_NONE',
+    COLUMN_ENGINE_REPLACING_TIMESERIES = 'COLUMN_ENGINE_REPLACING_TIMESERIES',
+}

package/dist/types/api/schema/externalDataSource.ts

@@ -0,0 +1,24 @@
+import type {TPathID} from './shared';
+
+export interface TExternalDataSourceDescription {
+    Name?: string;
+    PathId?: TPathID;
+    /** uint64 */
+    Version?: string;
+    SourceType?: string;
+    Location?: string;
+    Installation?: string;
+    Auth?: TAuth;
+}
+
+interface TAuth {
+    None?: NoneAuth;
+    ServiceAccount?: ServiceAccountAuth;
+}
+
+interface NoneAuth {}
+
+interface ServiceAccountAuth {
+    Id?: string;
+    SecretName?: string;
+}

package/dist/types/api/schema/externalTable.ts

@@ -0,0 +1,14 @@
+import type {TColumnDescription, TPathID} from './shared';
+
+export interface TExternalTableDescription {
+    Name?: string;
+    PathId?: TPathID;
+    /** uint64 */
+    Version?: string;
+    SourceType?: string;
+    DataSourcePath?: string;
+    Location?: string;
+    Columns?: TColumnDescription[];
+    /** bytes */
+    Content?: unknown;
+}

package/dist/types/api/schema/index.ts

@@ -0,0 +1,10 @@
+export * from './schema';
+export * from './shared';
+
+export * from './cdcStream';
+export * from './columnEntity';
+export * from './externalDataSource';
+export * from './externalTable';
+export * from './persQueueGroup';
+export * from './table';
+export * from './tableIndex';

package/dist/types/api/schema/persQueueGroup.ts

@@ -0,0 +1,191 @@
+export interface TPersQueueGroupDescription {
+    Name: string;
+    /** uint64 */
+    PathId?: string;
+    TotalGroupCount: number;
+
+    PartitionsToAdd?: TPartitionToAdd[];
+    PartitionsToDelete?: number[];
+    NextPartitionId?: number;
+    PartitionPerTablet?: number;
+    PQTabletConfig: TPQTabletConfig;
+    Partitions?: TPartition[];
+    /** uint64 */
+    AlterVersion?: string;
+    /** uint64 */
+    BalancerTabletID?: string;
+
+    PartitionBoundaries?: unknown;
+
+    BootstrapConfig?: TBootstrapConfig;
+}
+
+export interface TPQTabletConfig {
+    /** uint64 */
+    CacheSize?: string;
+    PartitionConfig: TPQPartitionConfig;
+    /** @deprecated use Partitions */
+    PartitionIds?: number[];
+    TopicName?: string;
+    Version?: number;
+    LocalDC?: boolean;
+    RequireAuthWrite?: boolean;
+    RequireAuthRead?: boolean;
+    Producer?: string;
+    Ident?: string;
+    Topic?: string;
+    DC?: string;
+
+    ReadRules?: string[];
+    /** uint64[] */
+    ReadFromTimestampsMs?: number[];
+    /** uint64[] */
+    ConsumerFormatVersions?: number[];
+
+    ConsumerCodecs?: TCodecs[];
+    ReadRuleServiceTypes?: string;
+
+    /** uint64 */
+    FormatVersion?: string;
+    Codecs?: TCodecs;
+
+    /** uint64[] */
+    ReadRuleVersions?: string[];
+    /** uint64[] */
+    ReadRuleGenerations?: string[];
+
+    TopicPath?: string;
+
+    YcCloudId?: string;
+    YcFolderId?: string;
+    YdbDatabaseId?: string;
+    YdbDatabasePath?: string;
+    FederationAccount?: string;
+
+    PartitionKeySchema?: TKeyComponentSchema[];
+
+    Partitions?: TPartition[];
+
+    MeteringMode?: EMeteringMode;
+}
+
+export interface TPQPartitionConfig {
+    MaxCountInPartition?: number;
+    /** int64 */
+    MaxSizeInPartition?: string;
+    LifetimeSeconds: number;
+    /** uint64 */
+    StorageLimitBytes?: string;
+
+    ImportantClientId?: string[];
+    LowWatermark?: number;
+    SourceIdLifetimeSeconds?: number;
+    SourceIdMaxCounts?: number;
+
+    /** uint64 */
+    WriteSpeedInBytesPerSecond?: string;
+    /** uint64 */
+    BurstSize?: string;
+
+    ReadQuota?: TReadQuota[];
+    /** uint64 */
+    MaxWriteInflightSize?: string;
+    /** uint64 */
+    BorderWriteInflightSize?: string;
+
+    NumChannels?: number;
+
+    TotalPartitions?: number;
+
+    ExplicitChannelProfiles?: TChannelProfile[];
+
+    MirrorFrom?: TMirrorPartitionConfig;
+}
+
+interface TMirrorPartitionConfig {
+    Endpoint?: string;
+    EndpointPort?: number;
+    Topic?: string;
+    Consumer?: string;
+    /** uint64 */
+    ReadFromTimestampsMs?: string;
+    Credentials?: TCredentials;
+    Database?: string;
+    UseSecureConnection?: boolean;
+    SyncWriteTime?: boolean;
+}
+
+interface TChannelProfile {
+    PoolKind?: string;
+    /** uint64 */
+    Size?: string;
+    ReadIops?: number;
+    ReadBandwidth?: number;
+    WriteIops?: number;
+    WriteBandwidth?: number;
+}
+
+interface IamCredentials {
+    Endpoint?: string;
+    ServiceAccountKey?: string;
+}
+
+interface TCredentials {
+    OauthToken?: string;
+    JwtParams?: string;
+    Iam?: IamCredentials;
+}
+
+interface TBootstrapConfig {
+    ExplicitMessageGroups?: TMessageGroup[];
+}
+
+interface TMessageGroup {
+    // Id of message group (SourceId)
+    Id?: string;
+    // Range of the key to which it is allowed to write.
+    KeyRange?: TPartitionKeyRange;
+}
+
+interface TKeyComponentSchema {
+    Name?: string;
+    TypeId?: number;
+}
+
+interface TReadQuota {
+    ClientId?: string;
+    /** uint64 */
+    SpeedInBytesPerSecond?: string;
+    /** uint64 */
+    BurstSize?: string;
+}
+
+interface TPartition {
+    PartitionId?: number;
+    /** uint64 */
+    TabletId?: string;
+    KeyRange?: TPartitionKeyRange;
+}
+
+interface TPartitionToAdd {
+    PartitionId?: number;
+    GroupId?: number;
+}
+
+interface TCodecs {
+    /** int64 */
+    Ids?: string[];
+    Codecs?: string[];
+}
+
+interface TPartitionKeyRange {
+    // Inclusive left border. Emptiness means -inf.
+    FromBound?: string;
+    // Exclusive right border. Emptiness means +inf.
+    ToBound?: string;
+}
+
+export enum EMeteringMode {
+    METERING_MODE_RESERVED_CAPACITY = 'METERING_MODE_RESERVED_CAPACITY',
+    METERING_MODE_REQUEST_UNITS = 'METERING_MODE_REQUEST_UNITS',
+}