@alauda-fe/storage 0.0.9 → 0.0.11

package/lib/types/commons.d.ts

@@ -21,7 +21,8 @@ export declare const StorageType: {
 export type StorageType = ValueOf<typeof StorageType>;
 export declare enum StorageclassFeature {
     SNAPSHOT = "snapshot",
-    EXPANSION = "expansion"
+    EXPANSION = "expansion",
+    CLONE = "clone"
 }
 export interface StorageOption {
     provisioner: StorageProvisioner;

package/lib/types/k8s.d.ts

@@ -1,4 +1,4 @@
-import { AccessMode, KubernetesResource, StringMap } from '@alauda-fe/common';
+import { AccessMode, Condition, KubernetesResource, StringMap, Affinity, ResourceRequirements } from '@alauda-fe/common';
 import { ReclaimPolicy, StorageProvisioner, VolumeBindingMode } from './commons';
 export interface VolumeSnapshotClass extends KubernetesResource {
     driver: string;
@@ -103,3 +103,350 @@ export interface PersistentVolumeSpecMeta {
         };
     };
 }
+export interface VolumeClaimTemplate extends KubernetesResource {
+    spec: {
+        accessModes: string[];
+        resources: {
+            requests: {
+                storage: string;
+            };
+        };
+        storageClassName: string;
+    };
+}
+export interface CephClusterNetwork {
+    ipFamily?: string;
+    provider?: string;
+}
+export interface CephClusterStatus {
+    ceph: {
+        health: string;
+        lastChecked: string;
+        details: unknown;
+        capacity?: {
+            bytesAvailable: number;
+            bytesTotal: number;
+            bytesUsed: number;
+            lastUpdated: string;
+        };
+    };
+    conditions: Condition[];
+    message: string;
+    phase: string;
+    state: string;
+    version: {
+        image: string;
+        version: string;
+    };
+    storage: {
+        deviceClasses: Array<{
+            name: string;
+        }>;
+    };
+    network: CephClusterNetwork;
+}
+declare const CephResourceConfigurationKeys: readonly ["mgr", "mon", "osd", "rbdmirror", "prepareosd", "crashcollector", "cleanup"];
+export interface CephDashBoardSpec {
+    enabled: boolean;
+    urlPrefix?: string;
+    port?: number;
+    ssl?: boolean;
+}
+export interface StretchCluster {
+    failureDomainLabel: string;
+    subFailureDomain: string;
+    zones: Array<{
+        name: string;
+        arbiter?: boolean;
+    }>;
+}
+export interface CephMonSettings {
+    count: number;
+    allowMultiplePerNode?: boolean;
+    volumeClaimTemplate?: PersistentVolumeSpec;
+    stretchCluster?: StretchCluster;
+}
+export interface CephMgrSettings {
+    modules: Array<{
+        name: string;
+        enabled: boolean;
+    }>;
+    count?: number;
+}
+export interface CephOsdConfiguration {
+    metadataDevice?: string;
+    storeType?: string;
+    databaseSizeMB?: number;
+    walSizeMB?: number;
+    osdsPerDevice?: number;
+    encryptedDevice?: boolean;
+    deviceClass?: string;
+}
+export interface CephNodeSettings {
+    name: string;
+    config?: CephOsdConfiguration;
+    useAllDevices?: boolean;
+    deviceFilter?: RegExp;
+    devicePathFilter?: RegExp;
+    devices?: Array<{
+        config?: {
+            deviceClass: string;
+        };
+        name: string;
+    }>;
+}
+export interface CephDisruptionManagement {
+    managePodBudgets?: boolean;
+    osdMaintenanceTimeout?: number;
+    manageMachineDisruptionBudgets?: boolean;
+    machineDisruptionBudgetNamespace?: string;
+}
+export interface CephStorageSettings {
+    useAllNodes?: boolean;
+    nodes: CephNodeSettings[];
+}
+declare const CephPlacementConfigurationKeys: readonly ["mgr", "mon", "rbdmirror", "cleanup", "all", "osd"];
+export interface CephPlacementNodeAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution: {
+        nodeSelectorTerms: Array<{
+            matchExpressions: Array<{
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+                values?: string[];
+            }>;
+        }>;
+    };
+}
+export interface CephPlacementConfiguration {
+    nodeAffinity?: CephPlacementNodeAffinity;
+    podAffinity?: Affinity;
+    podAntiAffinity?: Affinity;
+    tolerations?: any[];
+    topologySpreadConstraints?: any[];
+}
+export interface CephClusterSpec {
+    priorityClassNames?: StringMap;
+    external?: {
+        enable: boolean;
+    };
+    cephVersion: {
+        image: string;
+        allowUnsupported?: boolean;
+    };
+    dataDirHostPath: string;
+    skipUpgradeChecks?: boolean;
+    continueUpgradeAfterChecksEvenIfNotHealthy?: boolean;
+    dashboard?: CephDashBoardSpec;
+    mon: CephMonSettings;
+    mgr?: CephMgrSettings;
+    storage?: CephStorageSettings;
+    removeOSDsIfOutAndSafeToRemove?: boolean;
+    crashCollector?: {
+        disable: boolean;
+    };
+    network?: CephClusterNetwork;
+    disruptionManagement?: CephDisruptionManagement;
+    placement?: Partial<Record<Partial<typeof CephPlacementConfigurationKeys>[number], CephPlacementConfiguration>>;
+    resources?: Partial<Record<Partial<typeof CephResourceConfigurationKeys>[number], {
+        requests: {
+            cpu: string;
+            memory: string;
+        };
+    }>>;
+    monitoring?: {
+        enabled: boolean;
+        ruleNamespace?: string;
+    };
+}
+export interface CephCluster extends KubernetesResource {
+    spec: CephClusterSpec;
+    status?: CephClusterStatus;
+}
+export interface CephObjectPoolSpec {
+    deviceClass?: string;
+    failureDomain?: string;
+    replicated: {
+        size: number;
+        requireSafeReplicaSize?: boolean;
+    };
+    parameters?: {
+        compression_mode?: string;
+    };
+}
+export interface CephMetadataServer {
+    activeCount: number;
+    activeStandby?: boolean;
+    placement?: CephPlacementConfiguration;
+    resources: ResourceRequirements;
+}
+export interface CephFileSystem extends KubernetesResource {
+    spec: {
+        metadataPool?: any;
+        dataPools?: CephObjectPoolSpec[];
+        preservePoolsOnDelete?: boolean;
+        metadataServer?: CephMetadataServer;
+    };
+    status?: {
+        phase: string;
+    };
+}
+export interface CephBlockPool extends KubernetesResource {
+    spec: {
+        deviceClass?: string;
+        failureDomain: string;
+        replicated: {
+            size: number;
+        };
+    };
+    status?: any;
+}
+export interface CephObjectStore extends KubernetesResource {
+    spec: CephObjectStoreSpec;
+}
+export interface CephObjectStoreGateway {
+    type: string;
+    port: number;
+    instances: number;
+    placement: {
+        nodeAffinity: CephPlacementNodeAffinity;
+    };
+    annotations: unknown;
+    resources: {
+        limits: StringMap;
+    };
+}
+export interface CephObjectStoreSpec {
+    metadataPool?: CephObjectPoolSpec;
+    dataPool?: CephObjectPoolSpec;
+    preservePoolsOnDelete?: boolean;
+    gateway?: CephObjectStoreGateway;
+}
+export interface TopolvmNodeStorageStateClass {
+    className: string;
+    vgName: string;
+    deviceStates?: Array<{
+        name: string;
+        message?: string;
+        state: 'Online' | 'Offline';
+    }>;
+    state: 'Ready' | 'UnReady';
+}
+export interface TopolvmClusterStatus {
+    phase?: 'Ready' | 'Failure';
+    nodeStorageState?: Array<{
+        failClasses: TopolvmNodeStorageStateClass[];
+        successClasses: TopolvmNodeStorageStateClass[];
+        node: string;
+        phase: 'Ready' | 'Failure' | 'Unknown' | 'Pending' | '';
+    }>;
+}
+export type TopolvmDeviceType = 'disk' | 'loop' | 'lvm';
+export declare enum TopolvmClusterStorageDeviceClassStatusEnum {
+    AVAILABLE = "available",
+    NOT_AVAILABLE = "not_available"
+}
+export interface TopolvmClusterSpecDeviceClassItem {
+    className: string;
+    default: boolean;
+    volumeGroup: string;
+    devices: Array<{
+        name: string;
+        type: TopolvmDeviceType;
+    }>;
+}
+export interface TopolvmClusterSpecDeviceClass {
+    nodeName: string;
+    classes: TopolvmClusterSpecDeviceClassItem[];
+}
+export interface TopolvmClusterV2Spec {
+    cleanup?: boolean;
+    topolvmVersion: string;
+    storage?: {
+        deviceClasses: TopolvmClusterSpecDeviceClass[];
+    };
+}
+export interface TopolvmClusterV2 extends KubernetesResource {
+    spec: TopolvmClusterV2Spec;
+    status?: TopolvmClusterStatus;
+}
+export declare enum HealthStatus {
+    GREEN = "green",
+    YELLOW = "yellow",
+    RED = "red"
+}
+export declare enum PoolState {
+    POOL_NOT_CREATED = "PoolNotCreated",
+    POOL_CREATED = "PoolCreated",
+    POOL_INITIALIZED = "PoolInitialized"
+}
+export interface MinioClusterStatus {
+    currentState: string;
+    healthStatus: HealthStatus;
+    drivesOnline: number;
+    pools: Array<{
+        ssName: string;
+        state: PoolState;
+    }>;
+    usage: {
+        capacity: number;
+        usage: number;
+        rawCapacity: number;
+        rawUsage: number;
+    };
+}
+export interface MinioClusterPool {
+    affinity: {
+        podAntiAffinity?: Affinity;
+        nodeAffinity?: Affinity;
+    };
+    name: string;
+    servers: number;
+    volumesPerServer: number;
+    volumeClaimTemplate: VolumeClaimTemplate;
+    tolerations?: Array<{
+        effect: string;
+        operator: string;
+    }>;
+    resources?: {
+        limits?: {
+            cpu: string;
+            memory: string;
+        };
+        requests?: {
+            cpu: string;
+            memory: string;
+        };
+    };
+}
+export interface MinioClusterSpec {
+    configuration: {
+        name: string;
+    };
+    credsSecret: {
+        name: string;
+    };
+    image?: string;
+    requestAutoCert: boolean;
+    pools: MinioClusterPool[];
+    externalCertSecret?: Array<{
+        name: string;
+        type: string;
+    }>;
+    sideCars?: {
+        resources: {
+            limits?: {
+                cpu: string;
+                memory: string;
+            };
+            requests?: {
+                cpu: string;
+                memory: string;
+            };
+        };
+    };
+}
+export interface MinioCluster extends KubernetesResource {
+    spec: MinioClusterSpec;
+    status?: MinioClusterStatus;
+}
+export {};

package/lib/utils/constants.d.ts

@@ -4,6 +4,7 @@ export declare const AccessModeTranslateKey: {
     ReadWriteOnce: string;
     ReadOnlyMany: string;
     ReadWriteMany: string;
+    ReadWriteOncePod: string;
 };
 export declare const VolumeModeTranslateKey: {
     Filesystem: string;

package/lib/utils/util.d.ts

@@ -4,9 +4,8 @@ import { CommonStorageClass, PersistentVolume, StorageClass, VolumeSnapshot, Vol
 import { VolumeSnapshotStatus } from './constants';
 export declare function getProvisioner(sc: CommonStorageClass | StorageOption): StorageProvisioner;
 export declare function getProvisionerDisplay(sc: CommonStorageClass | StorageOption): Translation;
-export declare function getProvisionerType(provisioner: StorageProvisioner): "file_storage" | "object_storage" | "block_storage" | "unknown";
 export declare function getStorageclassVolumeModes(provisioner: StorageProvisioner): ("Filesystem" | "Block")[];
-export declare function getStorageclassAccessModes(provisioner: StorageProvisioner, isFromSnapshot?: boolean): ("ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany")[];
+export declare function getStorageclassAccessModes(provisioner: StorageProvisioner, isFromSnapshot?: boolean): ("ReadWriteOnce" | "ReadOnlyMany" | "ReadWriteMany" | "ReadWriteOncePod")[];
 export declare function isDefaultStorageclass(data: CommonStorageClass): boolean;
 export declare function isStorageClassSupportSnapshot(sc: StorageClass, vscList: VolumeSnapshotClass[]): boolean;
 export declare function buildPvcResource({ namespace, snapshot, volumeMode, }: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alauda-fe/storage",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "peerDependencies": {
     "@alauda/ui": "^8.0.0",
     "@alauda-fe/i18n": "1.0.11",