@alauda-fe/storage 0.0.1

package/esm2022/lib/utils/constants.mjs

@@ -0,0 +1,202 @@
+import { AccessMode, GenericStatusColor, GenericStatusIcon, VolumeMode, } from '@alauda-fe/common';
+import { StorageProvisioner, StorageType, StorageclassFeature, } from '../types/commons';
+import { StorageProvider } from '../types/internal';
+export const AccessModeTranslateKey = {
+    [AccessMode.RWO]: 'single_node_read_write',
+    [AccessMode.ROX]: 'multi_nodes_read_only',
+    [AccessMode.RWX]: 'multi_nodes_read_write',
+};
+export const VolumeModeTranslateKey = {
+    [VolumeMode.FILE_SYSTEM]: 'file_system',
+    [VolumeMode.BLOCK_DEVICE]: 'block_device',
+};
+export const IS_DEFAULT_STORAGECLASS_ANNOTATION = 'storageclass.kubernetes.io/is-default-class';
+export const RESERVED_STORAGECLASS_NAMES = [
+    'alauda-system-gfs',
+    'alauda-system-ebs',
+];
+export const CSI_TOP_SNAPSHOTCLASS_NAME = 'csi-topolvm-snapshotclass';
+export const CSI_CEPHFS_SNAPSHOTCLASS_NAME = 'csi-cephfs-snapshotclass';
+export const CSI_RBD_SNAPSHOTCLASS_NAME = 'csi-rbd-snapshotclass';
+export const OBJECT_STORAGE_FEATURE_GATE = 'object-storage';
+const TOPOLVM_CLUSTER_FEATURE_GATE = 'acp-topolvm';
+const HUAWEI_CSI_FEATURE_GATE = 'huawei-csi';
+const NFS_CSI_FEATURE_GATE = 'nfs-csi';
+const STORAGE_CEPH_FEATURE_GATE = 'storage-ceph';
+export const STORAGE_OPTION_MAP = {
+    [StorageProvisioner.CEPH_FS_INTERNAL]: {
+        provisioner: StorageProvisioner.CEPH_FS_INTERNAL,
+        clusterGate: STORAGE_CEPH_FEATURE_GATE,
+        provider: StorageProvider.PLATFORM,
+        type: StorageType.FILE_STORAGE,
+        display: {
+            en: 'CephFS File Storage',
+            zh: 'CephFS 文件存储',
+        },
+        accessModes: [AccessMode.RWO, AccessMode.RWX],
+        snapshotAccessModes: [AccessMode.ROX, AccessMode.RWO, AccessMode.RWX],
+        features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],
+        volumeModes: [VolumeMode.FILE_SYSTEM],
+    },
+    [StorageProvisioner.CEPH_FS_RBD]: {
+        provisioner: StorageProvisioner.CEPH_FS_RBD,
+        clusterGate: STORAGE_CEPH_FEATURE_GATE,
+        provider: StorageProvider.PLATFORM,
+        type: StorageType.BLOCK_STORAGE,
+        display: {
+            en: 'CephRBD Block Storage',
+            zh: 'CephRBD 块存储',
+        },
+        accessModes: [AccessMode.RWO],
+        snapshotAccessModes: [AccessMode.RWO],
+        features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],
+        volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],
+    },
+    [StorageProvisioner.CEPH_OBJECT]: {
+        provisioner: StorageProvisioner.CEPH_OBJECT,
+        clusterGate: OBJECT_STORAGE_FEATURE_GATE,
+        provider: StorageProvider.PLATFORM,
+        type: StorageType.OBJECT_STORAGE,
+        display: {
+            en: 'CephObject Distributed Storage',
+            zh: 'CephObject 分布式存储',
+        },
+        accessModes: [],
+        features: [StorageclassFeature.EXPANSION],
+        volumeModes: [],
+        disabled: true, // TODO: 存储桶需求不允许创建，后续下线该存储类
+    },
+    [StorageProvisioner.CEPH_COSI]: {
+        provisioner: StorageProvisioner.CEPH_COSI,
+        clusterGate: 'cosi',
+        module: 'cosi',
+        provider: StorageProvider.PLATFORM,
+        type: StorageType.OBJECT_STORAGE,
+        display: {
+            en: 'Ceph Object Storage',
+            zh: 'Ceph 对象存储',
+        },
+        accessModes: [],
+        features: [],
+        volumeModes: [],
+    },
+    [StorageProvisioner.MINIO]: {
+        provisioner: StorageProvisioner.MINIO,
+        clusterGate: 'cosi',
+        module: 'cosi',
+        provider: StorageProvider.PLATFORM,
+        type: StorageType.OBJECT_STORAGE,
+        display: {
+            en: 'MinIO Object Storage',
+            zh: 'MinIO 对象存储',
+        },
+        accessModes: [],
+        features: [],
+        volumeModes: [],
+    },
+    [StorageProvisioner.CEPH_FS]: {
+        provisioner: StorageProvisioner.CEPH_FS,
+        provider: StorageProvider.THIRD_PARTY,
+        type: StorageType.FILE_STORAGE,
+        display: {
+            en: 'CephFS',
+            zh: 'CephFS',
+        },
+        accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],
+        features: [],
+        volumeModes: [VolumeMode.FILE_SYSTEM],
+        disabled: true,
+    },
+    [StorageProvisioner.TOPOLVM]: {
+        provisioner: StorageProvisioner.TOPOLVM,
+        clusterGate: TOPOLVM_CLUSTER_FEATURE_GATE,
+        provider: StorageProvider.PLATFORM,
+        type: StorageType.BLOCK_STORAGE,
+        display: {
+            en: 'TopoLVM',
+            zh: 'TopoLVM',
+        },
+        accessModes: [AccessMode.RWO],
+        snapshotAccessModes: [AccessMode.RWO],
+        features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],
+        volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],
+    },
+    [StorageProvisioner.NFS]: {
+        provisioner: StorageProvisioner.NFS,
+        provider: StorageProvider.THIRD_PARTY,
+        type: StorageType.FILE_STORAGE,
+        display: {
+            en: 'NFS',
+            zh: 'NFS',
+        },
+        accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],
+        features: [],
+        volumeModes: [VolumeMode.FILE_SYSTEM],
+        disabled: true,
+    },
+    [StorageProvisioner.HUAWEI_CSI]: {
+        provisioner: StorageProvisioner.HUAWEI_CSI,
+        provider: StorageProvider.THIRD_PARTY,
+        clusterGate: HUAWEI_CSI_FEATURE_GATE,
+        display: {
+            en: 'OceanStor Pacific',
+            zh: 'OceanStor Pacific',
+        },
+        accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],
+        snapshotAccessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],
+        features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],
+        volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],
+        supportTypes: [StorageType.FILE_STORAGE, StorageType.BLOCK_STORAGE],
+    },
+    [StorageProvisioner.NFS_CSI]: {
+        provisioner: StorageProvisioner.NFS_CSI,
+        provider: StorageProvider.THIRD_PARTY,
+        type: StorageType.FILE_STORAGE,
+        clusterGate: NFS_CSI_FEATURE_GATE,
+        display: {
+            en: 'NFS CSI',
+            zh: 'NFS 共享存储',
+        },
+        accessModes: [AccessMode.RWO, AccessMode.RWX],
+        features: [],
+        volumeModes: [VolumeMode.FILE_SYSTEM],
+    },
+    [StorageProvisioner.CSTOR_CSI]: {
+        provisioner: StorageProvisioner.CSTOR_CSI,
+        provider: StorageProvider.THIRD_PARTY,
+        type: StorageType.BLOCK_STORAGE,
+        accessModes: [AccessMode.RWO],
+        features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],
+        volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],
+        disabled: true,
+    },
+};
+// 对于第三方 provider 的支持的 accessModes 和 volumeModes 不再做限制
+export const STORAGECLASS_UNKNOWN = {
+    provisioner: null,
+    provider: StorageProvider.THIRD_PARTY,
+    type: null,
+    accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],
+    features: [],
+    volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],
+};
+export var VolumeSnapshotStatus;
+(function (VolumeSnapshotStatus) {
+    VolumeSnapshotStatus["CREATING"] = "creating";
+    VolumeSnapshotStatus["AVAILABLE"] = "available";
+    VolumeSnapshotStatus["MALFUNCTION"] = "malfunction";
+    VolumeSnapshotStatus["DELETING"] = "deleting";
+})(VolumeSnapshotStatus || (VolumeSnapshotStatus = {}));
+export const VolumeSnapshotStatusColorMapper = {
+    [VolumeSnapshotStatus.CREATING]: GenericStatusColor.Pending,
+    [VolumeSnapshotStatus.AVAILABLE]: GenericStatusColor.Succeeded,
+    [VolumeSnapshotStatus.MALFUNCTION]: GenericStatusColor.Failed,
+    [VolumeSnapshotStatus.DELETING]: GenericStatusColor.Warning,
+};
+export const VolumeSnapshotStatusIconMapper = {
+    [VolumeSnapshotStatus.CREATING]: GenericStatusIcon.Pending,
+    [VolumeSnapshotStatus.AVAILABLE]: GenericStatusIcon.Check,
+    [VolumeSnapshotStatus.MALFUNCTION]: GenericStatusIcon.Warning,
+    [VolumeSnapshotStatus.DELETING]: GenericStatusIcon.Deleting,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../../modules/storage/src/lib/utils/constants.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AccessMode,\n  GenericStatusColor,\n  GenericStatusIcon,\n  VolumeMode,\n} from '@alauda-fe/common';\n\nimport {\n  StorageOption,\n  StorageProvisioner,\n  StorageType,\n  StorageclassFeature,\n} from '../types/commons';\nimport { StorageProvider } from '../types/internal';\n\nexport const AccessModeTranslateKey = {\n  [AccessMode.RWO]: 'single_node_read_write',\n  [AccessMode.ROX]: 'multi_nodes_read_only',\n  [AccessMode.RWX]: 'multi_nodes_read_write',\n};\n\nexport const VolumeModeTranslateKey = {\n  [VolumeMode.FILE_SYSTEM]: 'file_system',\n  [VolumeMode.BLOCK_DEVICE]: 'block_device',\n};\n\nexport const IS_DEFAULT_STORAGECLASS_ANNOTATION =\n  'storageclass.kubernetes.io/is-default-class';\n\nexport const RESERVED_STORAGECLASS_NAMES = [\n  'alauda-system-gfs',\n  'alauda-system-ebs',\n];\n\nexport const CSI_TOP_SNAPSHOTCLASS_NAME = 'csi-topolvm-snapshotclass';\nexport const CSI_CEPHFS_SNAPSHOTCLASS_NAME = 'csi-cephfs-snapshotclass';\nexport const CSI_RBD_SNAPSHOTCLASS_NAME = 'csi-rbd-snapshotclass';\nexport const OBJECT_STORAGE_FEATURE_GATE = 'object-storage';\n\nconst TOPOLVM_CLUSTER_FEATURE_GATE = 'acp-topolvm';\nconst HUAWEI_CSI_FEATURE_GATE = 'huawei-csi';\nconst NFS_CSI_FEATURE_GATE = 'nfs-csi';\nconst STORAGE_CEPH_FEATURE_GATE = 'storage-ceph';\n\nexport const STORAGE_OPTION_MAP: Record<StorageProvisioner, StorageOption> = {\n  [StorageProvisioner.CEPH_FS_INTERNAL]: {\n    provisioner: StorageProvisioner.CEPH_FS_INTERNAL,\n    clusterGate: STORAGE_CEPH_FEATURE_GATE,\n    provider: StorageProvider.PLATFORM,\n    type: StorageType.FILE_STORAGE,\n    display: {\n      en: 'CephFS File Storage',\n      zh: 'CephFS 文件存储',\n    },\n    accessModes: [AccessMode.RWO, AccessMode.RWX],\n    snapshotAccessModes: [AccessMode.ROX, AccessMode.RWO, AccessMode.RWX],\n    features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],\n    volumeModes: [VolumeMode.FILE_SYSTEM],\n  },\n  [StorageProvisioner.CEPH_FS_RBD]: {\n    provisioner: StorageProvisioner.CEPH_FS_RBD,\n    clusterGate: STORAGE_CEPH_FEATURE_GATE,\n    provider: StorageProvider.PLATFORM,\n    type: StorageType.BLOCK_STORAGE,\n    display: {\n      en: 'CephRBD Block Storage',\n      zh: 'CephRBD 块存储',\n    },\n    accessModes: [AccessMode.RWO],\n    snapshotAccessModes: [AccessMode.RWO],\n    features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],\n    volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],\n  },\n  [StorageProvisioner.CEPH_OBJECT]: {\n    provisioner: StorageProvisioner.CEPH_OBJECT,\n    clusterGate: OBJECT_STORAGE_FEATURE_GATE,\n    provider: StorageProvider.PLATFORM,\n    type: StorageType.OBJECT_STORAGE,\n    display: {\n      en: 'CephObject Distributed Storage',\n      zh: 'CephObject 分布式存储',\n    },\n    accessModes: [],\n    features: [StorageclassFeature.EXPANSION],\n    volumeModes: [],\n    disabled: true, // TODO: 存储桶需求不允许创建，后续下线该存储类\n  },\n  [StorageProvisioner.CEPH_COSI]: {\n    provisioner: StorageProvisioner.CEPH_COSI,\n    clusterGate: 'cosi',\n    module: 'cosi',\n    provider: StorageProvider.PLATFORM,\n    type: StorageType.OBJECT_STORAGE,\n    display: {\n      en: 'Ceph Object Storage',\n      zh: 'Ceph 对象存储',\n    },\n    accessModes: [],\n    features: [],\n    volumeModes: [],\n  },\n  [StorageProvisioner.MINIO]: {\n    provisioner: StorageProvisioner.MINIO,\n    clusterGate: 'cosi',\n    module: 'cosi',\n    provider: StorageProvider.PLATFORM,\n    type: StorageType.OBJECT_STORAGE,\n    display: {\n      en: 'MinIO Object Storage',\n      zh: 'MinIO 对象存储',\n    },\n    accessModes: [],\n    features: [],\n    volumeModes: [],\n  },\n  [StorageProvisioner.CEPH_FS]: {\n    provisioner: StorageProvisioner.CEPH_FS,\n    provider: StorageProvider.THIRD_PARTY,\n    type: StorageType.FILE_STORAGE,\n    display: {\n      en: 'CephFS',\n      zh: 'CephFS',\n    },\n    accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],\n    features: [],\n    volumeModes: [VolumeMode.FILE_SYSTEM],\n    disabled: true,\n  },\n  [StorageProvisioner.TOPOLVM]: {\n    provisioner: StorageProvisioner.TOPOLVM,\n    clusterGate: TOPOLVM_CLUSTER_FEATURE_GATE,\n    provider: StorageProvider.PLATFORM,\n    type: StorageType.BLOCK_STORAGE,\n    display: {\n      en: 'TopoLVM',\n      zh: 'TopoLVM',\n    },\n    accessModes: [AccessMode.RWO],\n    snapshotAccessModes: [AccessMode.RWO],\n    features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],\n    volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],\n  },\n  [StorageProvisioner.NFS]: {\n    provisioner: StorageProvisioner.NFS,\n    provider: StorageProvider.THIRD_PARTY,\n    type: StorageType.FILE_STORAGE,\n    display: {\n      en: 'NFS',\n      zh: 'NFS',\n    },\n    accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],\n    features: [],\n    volumeModes: [VolumeMode.FILE_SYSTEM],\n    disabled: true,\n  },\n  [StorageProvisioner.HUAWEI_CSI]: {\n    provisioner: StorageProvisioner.HUAWEI_CSI,\n    provider: StorageProvider.THIRD_PARTY,\n    clusterGate: HUAWEI_CSI_FEATURE_GATE,\n    display: {\n      en: 'OceanStor Pacific',\n      zh: 'OceanStor Pacific',\n    },\n    accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],\n    snapshotAccessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],\n    features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],\n    volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],\n    supportTypes: [StorageType.FILE_STORAGE, StorageType.BLOCK_STORAGE],\n  },\n  [StorageProvisioner.NFS_CSI]: {\n    provisioner: StorageProvisioner.NFS_CSI,\n    provider: StorageProvider.THIRD_PARTY,\n    type: StorageType.FILE_STORAGE,\n    clusterGate: NFS_CSI_FEATURE_GATE,\n    display: {\n      en: 'NFS CSI',\n      zh: 'NFS 共享存储',\n    },\n    accessModes: [AccessMode.RWO, AccessMode.RWX],\n    features: [],\n    volumeModes: [VolumeMode.FILE_SYSTEM],\n  },\n  [StorageProvisioner.CSTOR_CSI]: {\n    provisioner: StorageProvisioner.CSTOR_CSI,\n    provider: StorageProvider.THIRD_PARTY,\n    type: StorageType.BLOCK_STORAGE,\n    accessModes: [AccessMode.RWO],\n    features: [StorageclassFeature.SNAPSHOT, StorageclassFeature.EXPANSION],\n    volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],\n    disabled: true,\n  },\n};\n\n// 对于第三方 provider 的支持的 accessModes 和 volumeModes 不再做限制\nexport const STORAGECLASS_UNKNOWN: StorageOption = {\n  provisioner: null,\n  provider: StorageProvider.THIRD_PARTY,\n  type: null,\n  accessModes: [AccessMode.RWO, AccessMode.RWX, AccessMode.ROX],\n  features: [],\n  volumeModes: [VolumeMode.FILE_SYSTEM, VolumeMode.BLOCK_DEVICE],\n};\n\nexport enum VolumeSnapshotStatus {\n  CREATING = 'creating',\n  AVAILABLE = 'available',\n  MALFUNCTION = 'malfunction',\n  DELETING = 'deleting',\n}\n\nexport const VolumeSnapshotStatusColorMapper = {\n  [VolumeSnapshotStatus.CREATING]: GenericStatusColor.Pending,\n  [VolumeSnapshotStatus.AVAILABLE]: GenericStatusColor.Succeeded,\n  [VolumeSnapshotStatus.MALFUNCTION]: GenericStatusColor.Failed,\n  [VolumeSnapshotStatus.DELETING]: GenericStatusColor.Warning,\n};\n\nexport const VolumeSnapshotStatusIconMapper = {\n  [VolumeSnapshotStatus.CREATING]: GenericStatusIcon.Pending,\n  [VolumeSnapshotStatus.AVAILABLE]: GenericStatusIcon.Check,\n  [VolumeSnapshotStatus.MALFUNCTION]: GenericStatusIcon.Warning,\n  [VolumeSnapshotStatus.DELETING]: GenericStatusIcon.Deleting,\n};\n"]}

package/esm2022/lib/utils/resource-exports.mjs

@@ -0,0 +1,65 @@
+import { toUnitMi, toUnitNumM } from '@alauda-fe/common';
+import { ResourceSize } from '../types/resource-exports';
+export const getResourceSpecificationMapper = (specFromModels) => specFromModels.reduce((acc, curr) => {
+    acc[curr.size] = curr;
+    return acc;
+}, {});
+export const formatResource = ({ value, unit } = {}) => (value || value === 0 ? value + (unit === 'core' ? '' : unit) : undefined);
+export function getResourceSize(resources, resourceDefinitions) {
+    const { limits, requests } = resources || {};
+    const resourceLimitModel = resourceDefinitions.find(({ limits: resourceLimits, requests: resourceRequests }) => {
+        const limitsMatched = limits?.cpu === formatResource(resourceLimits?.cpu) &&
+            limits?.memory === formatResource(resourceLimits?.memory);
+        const requestsMatched = requests?.cpu === formatResource(resourceRequests?.cpu) &&
+            requests?.memory === formatResource(resourceRequests?.memory);
+        return limits && requests
+            ? limitsMatched && requestsMatched
+            : limitsMatched || requestsMatched;
+    });
+    return resourceLimitModel?.size || ResourceSize.CUSTOMIZE;
+}
+export function getResourceSizeTranslateKey(resources, resourceDefinitions) {
+    const size = getResourceSize(resources, resourceDefinitions);
+    return {
+        [size]: `storage.${size}_scale`,
+    }[size];
+}
+export function getResourceRequirements(resource) {
+    const cpuMValue = parseInt(toUnitNumM(resource?.cpu));
+    const memoryMiValue = parseInt(toUnitMi(resource?.memory));
+    const cpuCoreValue = cpuMValue / 1000;
+    const isCore = Number.isNaN(cpuCoreValue) || cpuCoreValue === Math.floor(cpuCoreValue);
+    const memoryGiValue = memoryMiValue / 1024;
+    const isGi = Number.isNaN(memoryGiValue) || memoryGiValue === Math.floor(memoryGiValue);
+    return {
+        cpu: {
+            value: cpuMValue === 0 ? 0 : (isCore ? cpuCoreValue : cpuMValue) || null,
+            unit: isCore ? 'core' : 'm',
+        },
+        memory: {
+            value: memoryMiValue === 0
+                ? 0
+                : (isGi ? memoryGiValue : memoryMiValue) || null,
+            unit: isGi ? 'Gi' : 'Mi',
+        },
+    };
+}
+export function getResourceSpecification(resources, resourceDefinitions) {
+    const size = getResourceSize(resources, resourceDefinitions);
+    if (size !== ResourceSize.CUSTOMIZE) {
+        return {
+            size,
+            ...getResourceSpecificationMapper(resourceDefinitions)[size],
+        };
+    }
+    return {
+        size,
+        ...(resources?.limits && {
+            limits: getResourceRequirements(resources?.limits),
+        }),
+        ...(resources?.requests && {
+            requests: getResourceRequirements(resources?.requests),
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-exports.js","sourceRoot":"","sources":["../../../../../../modules/storage/src/lib/utils/resource-exports.ts"],"names":[],"mappings":"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","sourcesContent":["import { LooseValueOf, toUnitMi, toUnitNumM } from '@alauda-fe/common';\n\nimport { ResourceSpecification, ResourceSize } from '../types/resource-exports';\nimport {\n  ResourceModel,\n  ResourceRequirements,\n} from '../types/resource-internals';\n\nexport const getResourceSpecificationMapper = (\n  specFromModels: ResourceSpecification[],\n) =>\n  specFromModels.reduce<Partial<Record<ResourceSize, ResourceSpecification>>>(\n    (acc, curr) => {\n      acc[curr.size] = curr;\n      return acc;\n    },\n    {},\n  );\n\nexport const formatResource = (\n  { value, unit } = {} as LooseValueOf<ResourceModel>,\n) => (value || value === 0 ? value + (unit === 'core' ? '' : unit) : undefined);\n\nexport function getResourceSize(\n  resources: ResourceRequirements,\n  resourceDefinitions: ResourceSpecification[],\n) {\n  const { limits, requests } = resources || {};\n\n  const resourceLimitModel = resourceDefinitions.find(\n    ({ limits: resourceLimits, requests: resourceRequests }) => {\n      const limitsMatched =\n        limits?.cpu === formatResource(resourceLimits?.cpu) &&\n        limits?.memory === formatResource(resourceLimits?.memory);\n\n      const requestsMatched =\n        requests?.cpu === formatResource(resourceRequests?.cpu) &&\n        requests?.memory === formatResource(resourceRequests?.memory);\n\n      return limits && requests\n        ? limitsMatched && requestsMatched\n        : limitsMatched || requestsMatched;\n    },\n  );\n\n  return resourceLimitModel?.size || ResourceSize.CUSTOMIZE;\n}\n\nexport function getResourceSizeTranslateKey(\n  resources: ResourceRequirements,\n  resourceDefinitions: ResourceSpecification[],\n) {\n  const size = getResourceSize(resources, resourceDefinitions);\n\n  return (\n    {\n      [size]: `storage.${size}_scale`,\n    } as Record<ResourceSize, string>\n  )[size];\n}\n\nexport function getResourceRequirements(resource: {\n  cpu: string;\n  memory: string;\n}): ResourceModel {\n  const cpuMValue = parseInt(toUnitNumM(resource?.cpu));\n  const memoryMiValue = parseInt(toUnitMi(resource?.memory));\n\n  const cpuCoreValue = cpuMValue / 1000;\n  const isCore =\n    Number.isNaN(cpuCoreValue) || cpuCoreValue === Math.floor(cpuCoreValue);\n\n  const memoryGiValue = memoryMiValue / 1024;\n  const isGi =\n    Number.isNaN(memoryGiValue) || memoryGiValue === Math.floor(memoryGiValue);\n\n  return {\n    cpu: {\n      value: cpuMValue === 0 ? 0 : (isCore ? cpuCoreValue : cpuMValue) || null,\n      unit: isCore ? 'core' : 'm',\n    },\n    memory: {\n      value:\n        memoryMiValue === 0\n          ? 0\n          : (isGi ? memoryGiValue : memoryMiValue) || null,\n      unit: isGi ? 'Gi' : 'Mi',\n    },\n  };\n}\n\nexport function getResourceSpecification(\n  resources: ResourceRequirements,\n  resourceDefinitions: ResourceSpecification[],\n): ResourceSpecification {\n  const size = getResourceSize(resources, resourceDefinitions);\n\n  if (size !== ResourceSize.CUSTOMIZE) {\n    return {\n      size,\n      ...getResourceSpecificationMapper(resourceDefinitions)[size],\n    };\n  }\n\n  return {\n    size,\n    ...(resources?.limits && {\n      limits: getResourceRequirements(resources?.limits),\n    }),\n    ...(resources?.requests && {\n      requests: getResourceRequirements(resources?.requests),\n    }),\n  };\n}\n"]}

package/esm2022/lib/utils/util.mjs

@@ -0,0 +1,132 @@
+import { TRUE, VOLUME_SNAPSHOT_GROUP, } from '@alauda-fe/common';
+import { PvcStatusEnum, PvStatusEnum, StorageProvisioner, VolumeBindingMode, } from '../types/commons';
+import { IS_DEFAULT_STORAGECLASS_ANNOTATION, STORAGECLASS_UNKNOWN, STORAGE_OPTION_MAP, VolumeSnapshotStatus, } from './constants';
+export function getProvisioner(sc) {
+    const provisioner = sc &&
+        ('provisioner' in sc
+            ? sc.provisioner
+            : 'driverName' in sc
+                ? sc.driverName
+                : null);
+    // CCE 集群上，不同存储使用相同的 provisioner(everest-csi-provisioner) 时需要进行额外处理
+    if (provisioner === 'everest-csi-provisioner') {
+        return sc?.parameters['csi.storage.k8s.io/csi-driver-name'];
+    }
+    return provisioner;
+}
+export function getProvisionerDisplay(sc) {
+    const provisioner = getProvisioner(sc);
+    return (STORAGE_OPTION_MAP[provisioner]?.display || {
+        en: provisioner,
+        zh: provisioner,
+    });
+}
+export function getProvisionerType(provisioner) {
+    return STORAGE_OPTION_MAP[provisioner]?.type || 'unknown';
+}
+export function getStorageclassVolumeModes(provisioner) {
+    return provisioner
+        ? (STORAGE_OPTION_MAP[provisioner] || STORAGECLASS_UNKNOWN).volumeModes
+        : ['Filesystem', 'Block']; // 针对未识别的 sc 全部卷模式可用
+}
+export function getStorageclassAccessModes(provisioner, isFromSnapshot = false) {
+    return provisioner
+        ? (STORAGE_OPTION_MAP[provisioner] || STORAGECLASS_UNKNOWN)[isFromSnapshot ? 'snapshotAccessModes' : 'accessModes']
+        : ['ReadOnlyMany', 'ReadWriteMany', 'ReadWriteOnce']; // 针对未识别的 sc 全部访问方式可用
+}
+export function isDefaultStorageclass(data) {
+    return (data.metadata.annotations?.[IS_DEFAULT_STORAGECLASS_ANNOTATION] === TRUE);
+}
+export function isStorageClassSupportSnapshot(sc, vscList) {
+    const list = vscList.filter(item => item.parameters?.clusterID === sc.parameters?.clusterID);
+    switch (sc.provisioner) {
+        case StorageProvisioner.CEPH_FS_INTERNAL: {
+            return list.some(item => item.driver === StorageProvisioner.CEPH_FS_INTERNAL);
+        }
+        case StorageProvisioner.CEPH_FS_RBD: {
+            return list.some(item => item.driver === StorageProvisioner.CEPH_FS_RBD);
+        }
+        case StorageProvisioner.TOPOLVM: {
+            return list.some(item => item.driver === StorageProvisioner.TOPOLVM);
+        }
+        default: {
+            return false;
+        }
+    }
+}
+export function buildPvcResource({ namespace, snapshot, volumeMode, }, pvc) {
+    return {
+        apiVersion: 'v1',
+        kind: 'PersistentVolumeClaim',
+        metadata: {
+            name: '',
+            namespace,
+            annotations: {},
+            labels: {},
+        },
+        spec: {
+            storageClassName: pvc?.spec?.storageClassName ?? null,
+            accessModes: pvc?.spec?.accessModes ?? ['ReadWriteOnce'],
+            volumeMode: volumeMode ?? 'Filesystem',
+            resources: {
+                requests: {
+                    storage: pvc?.spec?.resources.requests?.storage ?? null,
+                },
+            },
+            ...(pvc
+                ? {
+                    dataSource: {
+                        name: snapshot,
+                        kind: 'VolumeSnapshot',
+                        apiGroup: VOLUME_SNAPSHOT_GROUP,
+                    },
+                }
+                : {}),
+            selector: {
+                matchLabels: {},
+            },
+        },
+    };
+}
+export function getVolumeSnapshotStatus(resource) {
+    return resource.metadata?.deletionTimestamp
+        ? VolumeSnapshotStatus.DELETING
+        : resource.status?.error
+            ? VolumeSnapshotStatus.MALFUNCTION
+            : resource.status?.readyToUse
+                ? VolumeSnapshotStatus.AVAILABLE
+                : VolumeSnapshotStatus.CREATING;
+}
+export function getPvcStatus(status, refStorageclass) {
+    switch (status.phase.toLowerCase()) {
+        case 'pending': {
+            return refStorageclass?.volumeBindingMode ===
+                VolumeBindingMode.WaitForFirstConsumer
+                ? PvcStatusEnum.waiting
+                : PvcStatusEnum.processing;
+        }
+        case 'bound': {
+            return PvcStatusEnum.bound;
+        }
+        case 'lost': {
+            return PvcStatusEnum.invalid;
+        }
+    }
+}
+export function getPvStatus(pv) {
+    switch (pv.status.phase.toLowerCase()) {
+        case 'available': {
+            return PvStatusEnum.AVAILABLE;
+        }
+        case 'bound': {
+            return PvStatusEnum.BOUND;
+        }
+        case 'released': {
+            return PvStatusEnum.WAITING_RECYCLE;
+        }
+        case 'failed': {
+            return PvStatusEnum.RECYCLE_FAILED;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../modules/storage/src/lib/utils/util.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AccessMode,\n  PersistentVolumeClaim,\n  PersistentVolumeClaimStatus,\n  Translation,\n  TRUE,\n  VOLUME_SNAPSHOT_GROUP,\n  VolumeMode,\n} from '@alauda-fe/common';\n\nimport {\n  PvcStatusEnum,\n  PvStatusEnum,\n  StorageOption,\n  StorageProvisioner,\n  VolumeBindingMode,\n} from '../types/commons';\nimport {\n  CommonStorageClass,\n  PersistentVolume,\n  StorageClass,\n  VolumeSnapshot,\n  VolumeSnapshotClass,\n} from '../types/k8s';\n\nimport {\n  IS_DEFAULT_STORAGECLASS_ANNOTATION,\n  STORAGECLASS_UNKNOWN,\n  STORAGE_OPTION_MAP,\n  VolumeSnapshotStatus,\n} from './constants';\n\nexport function getProvisioner(sc: CommonStorageClass | StorageOption) {\n  const provisioner =\n    sc &&\n    ('provisioner' in sc\n      ? sc.provisioner\n      : 'driverName' in sc\n        ? sc.driverName\n        : null);\n\n  // CCE 集群上，不同存储使用相同的 provisioner(everest-csi-provisioner) 时需要进行额外处理\n  if (provisioner === ('everest-csi-provisioner' as StorageProvisioner)) {\n    return (sc as StorageClass)?.parameters[\n      'csi.storage.k8s.io/csi-driver-name'\n    ] as StorageProvisioner;\n  }\n  return provisioner;\n}\n\nexport function getProvisionerDisplay(\n  sc: CommonStorageClass | StorageOption,\n): Translation {\n  const provisioner = getProvisioner(sc);\n\n  return (\n    STORAGE_OPTION_MAP[provisioner]?.display || {\n      en: provisioner,\n      zh: provisioner,\n    }\n  );\n}\n\nexport function getProvisionerType(provisioner: StorageProvisioner) {\n  return STORAGE_OPTION_MAP[provisioner]?.type || 'unknown';\n}\n\nexport function getStorageclassVolumeModes(provisioner: StorageProvisioner) {\n  return provisioner\n    ? (STORAGE_OPTION_MAP[provisioner] || STORAGECLASS_UNKNOWN).volumeModes\n    : (['Filesystem', 'Block'] as VolumeMode[]); // 针对未识别的 sc 全部卷模式可用\n}\n\nexport function getStorageclassAccessModes(\n  provisioner: StorageProvisioner,\n  isFromSnapshot = false,\n) {\n  return provisioner\n    ? (STORAGE_OPTION_MAP[provisioner] || STORAGECLASS_UNKNOWN)[\n        isFromSnapshot ? 'snapshotAccessModes' : 'accessModes'\n      ]\n    : (['ReadOnlyMany', 'ReadWriteMany', 'ReadWriteOnce'] as AccessMode[]); // 针对未识别的 sc 全部访问方式可用\n}\n\nexport function isDefaultStorageclass(data: CommonStorageClass) {\n  return (\n    data.metadata.annotations?.[IS_DEFAULT_STORAGECLASS_ANNOTATION] === TRUE\n  );\n}\n\nexport function isStorageClassSupportSnapshot(\n  sc: StorageClass,\n  vscList: VolumeSnapshotClass[],\n) {\n  const list = vscList.filter(\n    item => item.parameters?.clusterID === sc.parameters?.clusterID,\n  );\n  switch (sc.provisioner) {\n    case StorageProvisioner.CEPH_FS_INTERNAL: {\n      return list.some(\n        item => item.driver === StorageProvisioner.CEPH_FS_INTERNAL,\n      );\n    }\n    case StorageProvisioner.CEPH_FS_RBD: {\n      return list.some(item => item.driver === StorageProvisioner.CEPH_FS_RBD);\n    }\n    case StorageProvisioner.TOPOLVM: {\n      return list.some(item => item.driver === StorageProvisioner.TOPOLVM);\n    }\n    default: {\n      return false;\n    }\n  }\n}\n\nexport function buildPvcResource(\n  {\n    namespace,\n    snapshot,\n    volumeMode,\n  }: { namespace: string; snapshot?: string; volumeMode?: VolumeMode },\n  pvc?: PersistentVolumeClaim, // 创建快照类 Pvc 时传入\n): PersistentVolumeClaim {\n  return {\n    apiVersion: 'v1',\n    kind: 'PersistentVolumeClaim',\n    metadata: {\n      name: '',\n      namespace,\n      annotations: {},\n      labels: {},\n    },\n    spec: {\n      storageClassName: pvc?.spec?.storageClassName ?? null,\n      accessModes: pvc?.spec?.accessModes ?? ['ReadWriteOnce'],\n      volumeMode: volumeMode ?? 'Filesystem',\n      resources: {\n        requests: {\n          storage: pvc?.spec?.resources.requests?.storage ?? null,\n        },\n      },\n      ...(pvc\n        ? {\n            dataSource: {\n              name: snapshot,\n              kind: 'VolumeSnapshot',\n              apiGroup: VOLUME_SNAPSHOT_GROUP,\n            },\n          }\n        : {}),\n      selector: {\n        matchLabels: {},\n      },\n    },\n  };\n}\n\nexport function getVolumeSnapshotStatus(resource: VolumeSnapshot) {\n  return resource.metadata?.deletionTimestamp\n    ? VolumeSnapshotStatus.DELETING\n    : resource.status?.error\n      ? VolumeSnapshotStatus.MALFUNCTION\n      : resource.status?.readyToUse\n        ? VolumeSnapshotStatus.AVAILABLE\n        : VolumeSnapshotStatus.CREATING;\n}\n\nexport function getPvcStatus(\n  status: PersistentVolumeClaimStatus,\n  refStorageclass?: StorageClass,\n): PvcStatusEnum {\n  switch (status.phase.toLowerCase()) {\n    case 'pending': {\n      return refStorageclass?.volumeBindingMode ===\n        VolumeBindingMode.WaitForFirstConsumer\n        ? PvcStatusEnum.waiting\n        : PvcStatusEnum.processing;\n    }\n    case 'bound': {\n      return PvcStatusEnum.bound;\n    }\n    case 'lost': {\n      return PvcStatusEnum.invalid;\n    }\n  }\n}\n\nexport function getPvStatus(pv: PersistentVolume): PvStatusEnum {\n  switch (pv.status.phase.toLowerCase()) {\n    case 'available': {\n      return PvStatusEnum.AVAILABLE;\n    }\n    case 'bound': {\n      return PvStatusEnum.BOUND;\n    }\n    case 'released': {\n      return PvStatusEnum.WAITING_RECYCLE;\n    }\n    case 'failed': {\n      return PvStatusEnum.RECYCLE_FAILED;\n    }\n  }\n}\n"]}

package/index.d.ts

@@ -0,0 +1,17 @@
+export { DeletePvcDialogComponent } from './lib/components/pvc-delete-dialog/component';
+export { PvcExpandCapacityDialogComponent } from './lib/components/pvc-expand-capacity-dialog/component';
+export { PersistentVolumeClaimFormComponent } from './lib/components/pvc-form/component';
+export { RebuildVolumeDialogComponent } from './lib/components/rebuild-volume-dialog/component';
+export { ResourceSpecFormComponent } from './lib/components/spec-form/component';
+export { StorageFeatureTagsComponent } from './lib/components/storage-feature-tags/component';
+export { StorageClassSelectComponent } from './lib/components/storageclass-select/component';
+export * from './lib/utils/constants';
+export * from './lib/utils/resource-exports';
+export * from './lib/utils/util';
+export * from './lib/types/commons';
+export * from './lib/types/k8s';
+export * from './lib/types/resource-definition';
+export * from './lib/types/resource-exports';
+export * from './lib/pipes/actual-capacity.pipe';
+export { StorageCommonUtilService, StorageSelectOption, } from './lib/services/common-util.service';
+export * from './lib/services/pvc-util.service';

package/lib/components/pvc-delete-dialog/component.d.ts

@@ -0,0 +1,33 @@
+import { DialogRef, MessageService } from '@alauda/ui';
+import { K8sApiService, K8sUtilService, KubernetesResource, PersistentVolumeClaim, TranslateService } from '@alauda-fe/common';
+import { BehaviorSubject } from 'rxjs';
+import { PVCUtilService } from '../../services/pvc-util.service';
+import { VolumeSnapshot } from '../../types/k8s';
+import * as i0 from "@angular/core";
+export declare class DeletePvcDialogComponent {
+    readonly modalData: {
+        cluster: string;
+        namespace: string;
+        pvc: PersistentVolumeClaim;
+    };
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    protected readonly pvcUtil: PVCUtilService;
+    private readonly dialogRef;
+    private readonly message;
+    private readonly translate;
+    COLUMNS: string[];
+    inputValue: string;
+    submitting$$: BehaviorSubject<boolean>;
+    pods$: import("rxjs").Observable<import("@alauda-fe/common").Pod[]>;
+    snapshots$: import("rxjs").Observable<VolumeSnapshot[]>;
+    list$: import("rxjs").Observable<KubernetesResource[]>;
+    constructor(modalData: {
+        cluster: string;
+        namespace: string;
+        pvc: PersistentVolumeClaim;
+    }, k8sApi: K8sApiService, k8sUtil: K8sUtilService, pvcUtil: PVCUtilService, dialogRef: DialogRef, message: MessageService, translate: TranslateService);
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeletePvcDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DeletePvcDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/components/pvc-expand-capacity-dialog/component.d.ts

@@ -0,0 +1,36 @@
+import { DialogRef, MessageService } from '@alauda/ui';
+import { K8sApiService, PersistentVolumeClaim, TranslateService } from '@alauda-fe/common';
+import { NgForm } from '@angular/forms';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PvcExpandCapacityDialogComponent {
+    dialogData: {
+        resource: PersistentVolumeClaim;
+        cluster: string;
+        namespace: string;
+        isVM?: boolean;
+    };
+    private readonly k8sApi;
+    private readonly dialogRef;
+    private readonly message;
+    private readonly translate;
+    newCapacity: string;
+    POSITIVE_INT_PATTERN: {
+        pattern: RegExp;
+        tip: string;
+    };
+    submitting$$: Subject<boolean>;
+    submitting$: import("rxjs").Observable<boolean>;
+    toUnitGi: (str?: string | number, negative?: boolean) => string;
+    constructor(dialogData: {
+        resource: PersistentVolumeClaim;
+        cluster: string;
+        namespace: string;
+        isVM?: boolean;
+    }, k8sApi: K8sApiService, dialogRef: DialogRef<PvcExpandCapacityDialogComponent>, message: MessageService, translate: TranslateService);
+    submit(ngForm: NgForm): void;
+    getNumber(capacity: string): number;
+    getVolumeTypeTranslateKey(isVM: boolean): "storage.virtual_disk_name" | "storage.pvc_short";
+    static ɵfac: i0.ɵɵFactoryDeclaration<PvcExpandCapacityDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PvcExpandCapacityDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}