@dao-style/biz 0.6.0 → 0.7.0

package/dist/components/gpu/src/components/AssignGpuDevicesList.vue2.js

@@ -0,0 +1,191 @@
+"use strict";
+const index = require("../../../../node_modules/@vueuse/core/index.js");
+const vue = require("vue");
+const vueI18n = require("vue-i18n");
+require("../../style/assign-gpu-devices-list.scss.js");
+const lodashEs = require("lodash-es");
+const extend = require("@dao-style/extend");
+const props = require("../../props.js");
+const _sfc_main = vue.defineComponent({
+  name: "DaoAssignGpuCardsList",
+  props: props.assignGpuDevicesListProps,
+  emits: ["update:modelValue"],
+  setup(props2, { emit }) {
+    const modelValue = index.useVModel(props2, "modelValue", emit, { passive: true });
+    const { t } = vueI18n.useI18n();
+    const columns = vue.computed(() => [
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.uuid"),
+        id: "deviceUUID"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.model"),
+        id: "modelName"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.node"),
+        id: "nodeName",
+        defaultWidth: "80px"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.computePower"),
+        id: "computePower",
+        defaultWidth: "170px"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.memory"),
+        id: "memory",
+        defaultWidth: "170px"
+      }
+    ]);
+    const searchOptions = vue.computed(() => [
+      {
+        key: "searchDeviceUUID",
+        label: t("biz.components.Gpu.assignGpu.devicesList.uuid"),
+        single: true
+      },
+      {
+        key: "searchGPUModel",
+        label: t("biz.components.Gpu.assignGpu.devicesList.model"),
+        single: true
+      },
+      {
+        key: "searchNodeName",
+        label: t("biz.components.Gpu.assignGpu.devicesList.node"),
+        single: true
+      }
+    ]);
+    const fuzzySearch = {
+      key: "searchDeviceUUID",
+      single: true
+    };
+    const filterData = vue.ref({});
+    const handleSearch = () => {
+      var _a, _b;
+      if (props2.disabled) {
+        return;
+      }
+      (_b = (_a = props2.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.search) == null ? void 0 : _b.call(_a, filterData.value);
+    };
+    const handleRefresh = () => {
+      var _a;
+      if (props2.disabled) {
+        return;
+      }
+      (_a = props2.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.refresh();
+    };
+    const displayDevices = vue.computed(() => {
+      var _a;
+      const devices = ((_a = props2.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.data) ?? [];
+      if (!props2.disabled) {
+        return devices;
+      }
+      const existingUUIDs = new Set(devices.map((device) => device.deviceUUID));
+      const missingDevices = modelValue.value.filter((deviceUUID) => !existingUUIDs.has(deviceUUID)).map((deviceUUID) => ({ deviceUUID }));
+      return [...devices, ...missingDevices];
+    });
+    const isEmpty = (value) => lodashEs.isNil(value) || value === "";
+    const formatMemoryUnit = (memory = "0") => {
+      if (memory === "0") {
+        return "0 Mi";
+      }
+      const val = extend.formatMemory(`${memory}Mi`);
+      return `${val.value} ${val.unit}`;
+    };
+    const calculateRemaining = (allocatable, allocated) => {
+      if (isEmpty(allocatable) || isEmpty(allocated)) {
+        return void 0;
+      }
+      const scale = 100;
+      const allocatableValue = Math.round(Number(allocatable) * scale);
+      const allocatedValue = Math.round(Number(allocated) * scale);
+      if (![allocatableValue, allocatedValue].every(Number.isFinite)) {
+        return void 0;
+      }
+      return ((allocatableValue - allocatedValue) / scale).toString();
+    };
+    const displayMemory = (row) => {
+      if (isEmpty(row.allocatedFrameBufferMemory)) {
+        return "-";
+      }
+      const allocated = formatMemoryUnit(row.allocatedFrameBufferMemory);
+      const remaining = calculateRemaining(
+        row.allocatableFrameBufferMemory,
+        row.allocatedFrameBufferMemory
+      );
+      const remainingText = lodashEs.isNil(remaining) ? "-" : formatMemoryUnit(remaining);
+      return `${allocated} / ${remainingText}`;
+    };
+    const displayComputePower = (row) => {
+      if (isEmpty(row.allocatedCore)) {
+        return "-";
+      }
+      const allocated = `${row.allocatedCore}%`;
+      const remaining = calculateRemaining(row.allocatableCore, row.allocatedCore);
+      const remainingText = lodashEs.isNil(remaining) ? "-" : `${remaining}%`;
+      return `${allocated} / ${remainingText}`;
+    };
+    const selectedDevices = vue.computed(() => {
+      const selectedUUIDs = new Set(modelValue.value);
+      return displayDevices.value.filter(
+        (device) => device.deviceUUID !== void 0 && selectedUUIDs.has(device.deviceUUID)
+      );
+    });
+    const hasAllSelectedDevices = (devices) => modelValue.value.every(
+      (deviceUUID) => devices.some((device) => device.deviceUUID === deviceUUID)
+    );
+    const firstSelectedDevice = vue.computed(() => selectedDevices.value[0] ?? null);
+    const getRowCheckable = (row) => {
+      if (props2.disabled) {
+        return false;
+      }
+      const first = firstSelectedDevice.value;
+      if (first) {
+        return row.nodeName === first.nodeName;
+      }
+      return true;
+    };
+    const onSelect = (selected) => {
+      var _a, _b;
+      if (props2.disabled) {
+        return;
+      }
+      if (!selected.length) {
+        modelValue.value = [];
+        return;
+      }
+      const selectedNodeName = ((_a = firstSelectedDevice.value) == null ? void 0 : _a.nodeName) ?? ((_b = selected[0]) == null ? void 0 : _b.nodeName);
+      modelValue.value = selected.reduce((uuids, device) => {
+        if (device.nodeName === selectedNodeName && device.deviceUUID !== void 0) {
+          uuids.push(device.deviceUUID);
+        }
+        return uuids;
+      }, []);
+    };
+    const fetchData = async () => {
+      var _a, _b;
+      const devices = ((_a = props2.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.data) ?? [];
+      const needsRefresh = !devices.length || props2.disabled && !hasAllSelectedDevices(devices);
+      if (!needsRefresh) {
+        return;
+      }
+      await ((_b = props2.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _b.refresh());
+    };
+    fetchData();
+    return {
+      columns,
+      selectedDevices,
+      displayDevices,
+      onSelect,
+      getRowCheckable,
+      displayComputePower,
+      displayMemory,
+      searchOptions,
+      fuzzySearch,
+      filterData,
+      handleSearch,
+      handleRefresh
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/components/gpu/src/components/AssignGpuDevicesList.vue2.mjs

@@ -0,0 +1,192 @@
+import { useVModel } from "../../../../node_modules/@vueuse/core/index.mjs";
+import { defineComponent, computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import "../../style/assign-gpu-devices-list.scss.mjs";
+import { isNil } from "lodash-es";
+import { formatMemory } from "@dao-style/extend";
+import { assignGpuDevicesListProps } from "../../props.mjs";
+const _sfc_main = defineComponent({
+  name: "DaoAssignGpuCardsList",
+  props: assignGpuDevicesListProps,
+  emits: ["update:modelValue"],
+  setup(props, { emit }) {
+    const modelValue = useVModel(props, "modelValue", emit, { passive: true });
+    const { t } = useI18n();
+    const columns = computed(() => [
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.uuid"),
+        id: "deviceUUID"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.model"),
+        id: "modelName"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.node"),
+        id: "nodeName",
+        defaultWidth: "80px"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.computePower"),
+        id: "computePower",
+        defaultWidth: "170px"
+      },
+      {
+        header: t("biz.components.Gpu.assignGpu.devicesList.memory"),
+        id: "memory",
+        defaultWidth: "170px"
+      }
+    ]);
+    const searchOptions = computed(() => [
+      {
+        key: "searchDeviceUUID",
+        label: t("biz.components.Gpu.assignGpu.devicesList.uuid"),
+        single: true
+      },
+      {
+        key: "searchGPUModel",
+        label: t("biz.components.Gpu.assignGpu.devicesList.model"),
+        single: true
+      },
+      {
+        key: "searchNodeName",
+        label: t("biz.components.Gpu.assignGpu.devicesList.node"),
+        single: true
+      }
+    ]);
+    const fuzzySearch = {
+      key: "searchDeviceUUID",
+      single: true
+    };
+    const filterData = ref({});
+    const handleSearch = () => {
+      var _a, _b;
+      if (props.disabled) {
+        return;
+      }
+      (_b = (_a = props.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.search) == null ? void 0 : _b.call(_a, filterData.value);
+    };
+    const handleRefresh = () => {
+      var _a;
+      if (props.disabled) {
+        return;
+      }
+      (_a = props.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.refresh();
+    };
+    const displayDevices = computed(() => {
+      var _a;
+      const devices = ((_a = props.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.data) ?? [];
+      if (!props.disabled) {
+        return devices;
+      }
+      const existingUUIDs = new Set(devices.map((device) => device.deviceUUID));
+      const missingDevices = modelValue.value.filter((deviceUUID) => !existingUUIDs.has(deviceUUID)).map((deviceUUID) => ({ deviceUUID }));
+      return [...devices, ...missingDevices];
+    });
+    const isEmpty = (value) => isNil(value) || value === "";
+    const formatMemoryUnit = (memory = "0") => {
+      if (memory === "0") {
+        return "0 Mi";
+      }
+      const val = formatMemory(`${memory}Mi`);
+      return `${val.value} ${val.unit}`;
+    };
+    const calculateRemaining = (allocatable, allocated) => {
+      if (isEmpty(allocatable) || isEmpty(allocated)) {
+        return void 0;
+      }
+      const scale = 100;
+      const allocatableValue = Math.round(Number(allocatable) * scale);
+      const allocatedValue = Math.round(Number(allocated) * scale);
+      if (![allocatableValue, allocatedValue].every(Number.isFinite)) {
+        return void 0;
+      }
+      return ((allocatableValue - allocatedValue) / scale).toString();
+    };
+    const displayMemory = (row) => {
+      if (isEmpty(row.allocatedFrameBufferMemory)) {
+        return "-";
+      }
+      const allocated = formatMemoryUnit(row.allocatedFrameBufferMemory);
+      const remaining = calculateRemaining(
+        row.allocatableFrameBufferMemory,
+        row.allocatedFrameBufferMemory
+      );
+      const remainingText = isNil(remaining) ? "-" : formatMemoryUnit(remaining);
+      return `${allocated} / ${remainingText}`;
+    };
+    const displayComputePower = (row) => {
+      if (isEmpty(row.allocatedCore)) {
+        return "-";
+      }
+      const allocated = `${row.allocatedCore}%`;
+      const remaining = calculateRemaining(row.allocatableCore, row.allocatedCore);
+      const remainingText = isNil(remaining) ? "-" : `${remaining}%`;
+      return `${allocated} / ${remainingText}`;
+    };
+    const selectedDevices = computed(() => {
+      const selectedUUIDs = new Set(modelValue.value);
+      return displayDevices.value.filter(
+        (device) => device.deviceUUID !== void 0 && selectedUUIDs.has(device.deviceUUID)
+      );
+    });
+    const hasAllSelectedDevices = (devices) => modelValue.value.every(
+      (deviceUUID) => devices.some((device) => device.deviceUUID === deviceUUID)
+    );
+    const firstSelectedDevice = computed(() => selectedDevices.value[0] ?? null);
+    const getRowCheckable = (row) => {
+      if (props.disabled) {
+        return false;
+      }
+      const first = firstSelectedDevice.value;
+      if (first) {
+        return row.nodeName === first.nodeName;
+      }
+      return true;
+    };
+    const onSelect = (selected) => {
+      var _a, _b;
+      if (props.disabled) {
+        return;
+      }
+      if (!selected.length) {
+        modelValue.value = [];
+        return;
+      }
+      const selectedNodeName = ((_a = firstSelectedDevice.value) == null ? void 0 : _a.nodeName) ?? ((_b = selected[0]) == null ? void 0 : _b.nodeName);
+      modelValue.value = selected.reduce((uuids, device) => {
+        if (device.nodeName === selectedNodeName && device.deviceUUID !== void 0) {
+          uuids.push(device.deviceUUID);
+        }
+        return uuids;
+      }, []);
+    };
+    const fetchData = async () => {
+      var _a, _b;
+      const devices = ((_a = props.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.data) ?? [];
+      const needsRefresh = !devices.length || props.disabled && !hasAllSelectedDevices(devices);
+      if (!needsRefresh) {
+        return;
+      }
+      await ((_b = props.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _b.refresh());
+    };
+    fetchData();
+    return {
+      columns,
+      selectedDevices,
+      displayDevices,
+      onSelect,
+      getRowCheckable,
+      displayComputePower,
+      displayMemory,
+      searchOptions,
+      fuzzySearch,
+      filterData,
+      handleSearch,
+      handleRefresh
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/gpu/src/components/GpuAdvancedForm.vue.d.ts

@@ -0,0 +1,180 @@
+import * as yup from 'yup';
+import { VgpuSchedulePolicy } from '../../types';
+type AssignGpuType = 'assignModel' | 'assignDevice';
+declare const _default: import("vue").DefineComponent<{
+    quota: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+    };
+    enableRemoteCall: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuModel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuDevices: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    assignGpuDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuPriority: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuModelsAdaptor: {
+        type: import("vue").PropType<{
+            data: import("../../types").GPUSummary[];
+            loading: boolean;
+            refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+        }>;
+        default: undefined;
+    };
+    nvidiaGpuModels: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+    };
+    nvidiaVgpuDevicesAdaptor: {
+        type: import("vue").PropType<import("../../props").GpuDevicesAdaptor>;
+        default: undefined;
+    };
+    isSide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openNvidiaAssignGpu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openNvidiaVgpuModel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuSchedulePolicy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openNvidiaVgpuSchedulePolicy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    gpuCallValue: import("vue").Ref<string>;
+    priorityOpts: {
+        label: string;
+        value: string;
+    }[];
+    openNvidiaVgpuModelRef: import("vue").Ref<boolean> | import("vue").WritableComputedRef<boolean>;
+    nvidiaVgpuModelKey: string;
+    nvidiaVgpuPriorityKey: string;
+    isNvidiaVgpuType: import("vue").ComputedRef<boolean>;
+    isNvidiaGpu: (key?: string | undefined) => boolean;
+    showAdvancedConfig: import("vue").ComputedRef<boolean>;
+    scheduleOps: {
+        label: string;
+        value: VgpuSchedulePolicy;
+    }[];
+    openNvidiaVgpuSchedulePolicyRef: import("vue").Ref<boolean> | import("vue").WritableComputedRef<boolean>;
+    handleNvidiaVgpuSchedulePolicyChange: (open: boolean) => void;
+    nvidiaVgpuGpuScheduleKey: string;
+    nvidiaVgpuNodeScheduleKey: string;
+    nodeScheduleHelper: import("vue").ComputedRef<string>;
+    gpuScheduleHelper: import("vue").ComputedRef<string>;
+    nvidiaVgpuCore: import("vue").ComputedRef<number | undefined>;
+    assignTypes: import("vue").ComputedRef<{
+        value: AssignGpuType;
+        label: string;
+    }[]>;
+    openNvidiaAssignGpuRef: import("vue").Ref<boolean> | import("vue").WritableComputedRef<boolean>;
+    handleAssignGpuTypeChange: (value: AssignGpuType) => void;
+    assignGpuType: import("vue").Ref<AssignGpuType>;
+    displayNvidiaGpuModels: import("vue").ComputedRef<string[]>;
+    nvidiaVgpuDevicesKey: string;
+    yupDevicesSchema: import("vue").ComputedRef<yup.ArraySchema<import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>, import("yup/lib/types").AnyObject, (string | undefined)[] | undefined, string[] | undefined>>;
+    yup: typeof yup;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:openNvidiaVgpuModel" | "update:openNvidiaVgpuSchedulePolicy" | "update:openNvidiaAssignGpu")[], "update:openNvidiaVgpuModel" | "update:openNvidiaVgpuSchedulePolicy" | "update:openNvidiaAssignGpu", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    quota: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+    };
+    enableRemoteCall: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuModel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuDevices: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    assignGpuDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuPriority: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuModelsAdaptor: {
+        type: import("vue").PropType<{
+            data: import("../../types").GPUSummary[];
+            loading: boolean;
+            refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+        }>;
+        default: undefined;
+    };
+    nvidiaGpuModels: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+    };
+    nvidiaVgpuDevicesAdaptor: {
+        type: import("vue").PropType<import("../../props").GpuDevicesAdaptor>;
+        default: undefined;
+    };
+    isSide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openNvidiaAssignGpu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openNvidiaVgpuModel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuSchedulePolicy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openNvidiaVgpuSchedulePolicy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:openNvidiaVgpuModel"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:openNvidiaVgpuSchedulePolicy"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:openNvidiaAssignGpu"?: ((...args: any[]) => any) | undefined;
+}, {
+    nvidiaVgpuModelsAdaptor: {
+        data: import("../../types").GPUSummary[];
+        loading: boolean;
+        refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+    };
+    nvidiaVgpuDevicesAdaptor: import("../../props").GpuDevicesAdaptor;
+    enableRemoteCall: boolean;
+    enableNvidiaVgpuModel: boolean;
+    enableNvidiaVgpuDevices: boolean;
+    assignGpuDisabled: boolean;
+    enableNvidiaVgpuPriority: boolean;
+    enableNvidiaVgpuSchedulePolicy: boolean;
+    isSide: boolean;
+    openNvidiaAssignGpu: boolean;
+    openNvidiaVgpuModel: boolean;
+    openNvidiaVgpuSchedulePolicy: boolean;
+}>;
+export default _default;