bfg-common 1.5.417 → 1.5.419

package/components/common/pages/backups/modals/lib/config/restore.ts

@@ -0,0 +1,115 @@
+import type { UI_I_RestoreForm } from '~/components/common/pages/backups/modals/lib/models/interfaces'
+
+export const restoreDefaultFormFunc = (): UI_I_RestoreForm => {
+  return {
+    restore_code: 2,
+    backup_storage: '',
+    bucket: '',
+    backup: '',
+    pvm: {
+      deployment_name: '',
+      name: '',
+      uuid: '',
+      compatibility: '',
+      guest_os_family: '',
+      guest_os_version: '',
+      storage: {
+        id: '',
+        folder: '',
+      },
+      machine_type: '',
+      cpu: {
+        vcpus: -1,
+        max_vcpus: -1,
+        core_per_socket: -1,
+        model: '',
+        reservation_mhz: -1,
+        limit_mhz: -1,
+        shares: -1,
+        hotplug: false,
+      },
+      memory: {
+        size_mb: -1,
+        hotplug: false,
+        reservation_mb: -1,
+        limit_mb: -1,
+      },
+      video_card: {
+        adapter: '',
+        displays: -1,
+        memory_mb: -1,
+      },
+      usb_controllers: [],
+      input_devices: [],
+      disk_devices: [],
+      network_devices: [],
+      passthrough_pci_devices: [],
+      options: {
+        remote_console: {
+          type: '',
+          port: -1,
+          keymap: '',
+          password: '',
+          guest_os_lock: false,
+          limit_sessions: -1,
+          spice: {
+            img_compression: '',
+            jpeg_compression: '',
+            zlib_glz_compression: '',
+            streaming_mode: '',
+            playback_compression: false,
+            file_transfer: false,
+            clipboard: false,
+          },
+        },
+        guest_tools: {
+          enabled: false,
+          synchronized_time: false,
+        },
+        boot_options: {
+          firmware: '',
+          boot_delay_ms: -1,
+          boot_menu: false,
+        },
+      },
+      monitoring: {
+        state: -1,
+        memory: {
+          dram_read_bandwidth: -1,
+          pmem_read_bandwidth: -1,
+          provisioned_mb: -1,
+          used_mb: -1,
+          resident_set_size_mb: -1,
+        },
+        cpu: {
+          current_vcpus: -1,
+          provisioned_mhz: -1,
+          used_mhz: -1,
+        },
+        storage: {
+          provisioned_space_mb: -1,
+          used_space_mb: -1,
+          allocated_space_mb: -1,
+        },
+        networks: null,
+        uptime: {
+          start_time: '',
+          uptime_ms: -1,
+          uptime_humanized: '',
+        },
+        guest_tools: {
+          status: '',
+          version: '',
+          ip: '',
+          dns_name: '',
+        },
+        evc_cpu_mode: '',
+        evc_graphics_mode: '',
+        encryption: '',
+        tpm: '',
+        vbs: '',
+      },
+      snapshots: {},
+    },
+  }
+}

package/components/common/pages/backups/modals/lib/models/interfaces.ts

@@ -0,0 +1,164 @@
+export interface API_UI_I_Pvm {
+  compatibility: string
+  deployment_name: string
+  guest_os_family: string
+  guest_os_version: string
+  machine_type: string
+  name: string
+  uuid: string
+  cpu: {
+    core_per_socket: number
+    hotplug: boolean
+    limit_mhz: number
+    max_vcpus: number
+    model: string
+    reservation_mhz: number
+    shares: number
+    vcpus: number
+  }
+  disk_devices: {
+    allocated_mb: number
+    boot_order: number
+    bus: string
+    cache: string
+    capacity_mb: number
+    device_type: string
+    discard: string
+    disk_mode: string
+    free_mb: number
+    io: string
+    limit_iops: number
+    location: string
+    provision_type: string
+    read_only: boolean
+    shares: number
+    sharing: boolean
+    source: string
+    storage_id: string
+    target: string
+    used_mb: number
+    volume_path: string
+  }[]
+  input_devices: {
+    bus: string
+    type: string
+  }[]
+  memory: {
+    hotplug: boolean
+    limit_mb: number
+    reservation_mb: number
+    size_mb: number
+  }
+  monitoring: {
+    cpu: {
+      current_vcpus: number
+      provisioned_mhz: number
+      used_mhz: number
+    }
+    encryption: string
+    evc_cpu_mode: string
+    evc_graphics_mode: string
+    guest_tools: {
+      dns_name: string
+      ip: string
+      status: string
+      version: string
+    }
+    memory: {
+      dram_read_bandwidth: number
+      pmem_read_bandwidth: number
+      provisioned_mb: number
+      resident_set_size_mb: number
+      used_mb: number
+    }
+    networks: null // ?
+    state: number
+    storage: {
+      allocated_space_mb: number
+      provisioned_space_mb: number
+      used_space_mb: number
+    }
+    tpm: string
+    uptime: {
+      start_time: string
+      uptime_humanized: string
+      uptime_ms: number
+    }
+    vbs: string
+  }
+  network_devices: {
+    boot_order: number
+    import_source_id: string
+    mac: string
+    model: string
+    net_bridge: string
+    network: string
+    target: string
+  }[]
+  options: {
+    boot_options: {
+      boot_delay_ms: number
+      boot_menu: boolean
+      firmware: string
+    }
+    guest_tools: {
+      enabled: boolean
+      synchronized_time: boolean
+    }
+    remote_console: {
+      guest_os_lock: boolean
+      keymap: string
+      limit_sessions: number
+      password: string
+      port: number
+      spice: {
+        clipboard: boolean
+        file_transfer: boolean
+        img_compression: string
+        jpeg_compression: string
+        playback_compression: boolean
+        streaming_mode: string
+        zlib_glz_compression: string
+      }
+      type: string
+    }
+  }
+  passthrough_pci_devices: any[]
+  snapshots: any
+  storage: {
+    folder: string
+    id: string
+  }
+  usb_controllers: {
+    type: string
+  }[]
+  video_card: {
+    adapter: string
+    displays: number
+    memory_mb: number
+  }
+}
+export interface UI_I_Pvm extends API_UI_I_Pvm {}
+
+export interface UI_I_CreateBackupFormDiskDevice {
+  location: string,
+  target: string,
+}
+export interface UI_I_CreateBackupForm {
+  target: string
+  name: string
+  description: string
+  disk_devices: UI_I_CreateBackupFormDiskDevice[]
+  backup_storage: string
+  strategy: 0 | 1 | 2
+  // start_window_min: number
+  bandwidth_limit: number
+}
+
+export interface UI_I_RestoreForm {
+  restore_code: 1 | 2 | 3 // 1 - disk only, 2 - existing, 3 - asNew
+  backup_storage: string
+  bucket: string
+  backup: string
+  pvm: UI_I_Pvm
+}

package/components/common/pages/backups/modals/restore/Restore.vue

@@ -0,0 +1,388 @@
+<template>
+  <div class="restore">
+    <atoms-wizard
+      show
+      :wizard="wizard"
+      :selected-scheme="selectedScheme"
+      :title="localization.common.restore"
+      :localization="localization"
+      test-id="restore"
+      @change-steps="onChangeSteps"
+      @hide="onHideModal"
+      @submit="onRestore"
+    >
+      <template #modalBody="{ selectedStep }">
+        <div
+          v-show="isLoading"
+          class="loader-wrap absolute left-0 right-0 top-0 bottom-0"
+        >
+          <atoms-loader-pre-loader
+            id="loader"
+            :show="isLoading"
+            class="absolute-center"
+            test-id="backup-restore-spinner"
+          />
+        </div>
+        <atoms-alert
+          v-show="errors.length"
+          :items="errors"
+          status="alert-danger"
+          test-id="restore-alert"
+          @remove="onRemoveValidationErrors"
+        />
+
+        <common-pages-backups-modals-restore-types
+          v-show="selectedStep.id === 0"
+          v-model="model"
+        />
+
+        <common-pages-backups-modals-restore-name
+          v-show="selectedStep.id === 1"
+          v-model="model"
+          :show="selectedStep.id === 1"
+          :name-form-submit="nameFormSubmit"
+          @check-name="onCheckName(...$event)"
+        />
+
+        <!--        TODO refactoring-->
+        <common-vm-actions-common-select-storage
+          v-show="selectedStep.id === 2"
+          :storage-submit="storageSubmit"
+          :datastore="props.datastore"
+          :is-datastore-loading="props.datastoreLoading"
+          :storage="model.pvm.storage"
+          :get-datastore-table-func="getDatastoreTableFunc"
+          @submit="onChangeStorage"
+        />
+
+        <common-pages-backups-modals-restore-disks
+          v-show="selectedStep.id === 3"
+          v-model="model"
+        />
+        <common-pages-backups-modals-restore-networks
+          v-if="selectedStep.id === 4"
+          v-model="model"
+          :alert-messages="[]"
+          :networks="props.networks"
+          @get-networks="onGetNetworks"
+        />
+
+        <common-ready-to-complete
+          v-show="selectedStep.id === 5"
+          :data="readyToCompleteInfo"
+        />
+      </template>
+    </atoms-wizard>
+  </div>
+
+  <common-modals-confirmation
+    v-if="isShowConfirm"
+    :headline="localization.common.attention"
+    :description="localization.common.restoreBackupConfirmDescription"
+    @hide-modal="isShowConfirm = false"
+    @confirm="onFinish"
+  />
+</template>
+
+<script setup lang="ts">
+import type { UI_I_Localization } from '~/lib/models/interfaces'
+import type {
+  UI_I_WizardStep,
+  UI_I_ValidationReturn,
+} from '~/components/atoms/wizard/lib/models/interfaces'
+import Wizard from '~/components/atoms/wizard/lib/utils/utils'
+import type { UI_I_DatastoreTableItem } from '~/lib/models/store/storage/interfaces'
+import type { UI_I_TableInfoItem } from '~/components/atoms/table/info/lib/models/interfaces'
+import type { API_UI_I_Error } from '~/lib/models/store/interfaces'
+import type { UI_I_NetworkTableItem } from '~/lib/models/store/network/interfaces'
+// import type { I_RestoreForm } from '~/components/common/pages/backups/modals/lib/models/interfaces'
+import {
+  stepsSchemeInitial,
+  stepsFunc,
+} from '~/components/common/pages/backups/modals/restore/lib/config/steps'
+// import { datastoreTableFunc } from '~/components/templates/inventory/actions/vm/lib/utils'
+
+const model = defineModel<I_RestoreForm>({ required: true })
+
+const props = defineProps<{
+  datastore: UI_I_DatastoreTableItem[]
+  datastoreLoading: boolean
+  networks: UI_I_NetworkTableItem[]
+}>()
+const emits = defineEmits<{
+  (event: 'get-datastore', value: string): void
+  (event: 'get-networks', value: string): void
+  (event: 'check-name', value: any): void // ??
+  (event: 'finish'): void
+  (event: 'hide'): void
+}>()
+
+const { $store } = useNuxtApp()
+
+const localization = computed<UI_I_Localization>(() => useLocal())
+
+const wizard: Wizard = new Wizard(
+  stepsFunc(localization.value),
+  stepsSchemeInitial
+)
+
+watch(
+  () => model.value.restore_code,
+  (newValue) => {
+    wizard.changeScheme(newValue - 1)
+  },
+  { immediate: true }
+)
+const selectedScheme = computed<number[]>(() => wizard.selectedScheme.value)
+const onChangeSteps = async (value: UI_I_WizardStep[]): Promise<void> => {
+  wizard.changeSteps(value, validationFunc)
+}
+
+const nameFormSubmit = ref<null | Function>(null)
+const storageSubmit = ref<null | Function>(null)
+
+const validationFunc = async (
+  value: UI_I_WizardStep[],
+  currentStep: UI_I_WizardStep,
+  nextStep: UI_I_WizardStep
+): Promise<UI_I_ValidationReturn> => {
+  let stepHasError = false
+  const stepShouldStop = {
+    ifOnCurrentStep: false,
+    ifFromAnyStep: false,
+    stoppageStepId: -1,
+  }
+
+  wizard.setLoader(true)
+
+  if (wizard.isValidateForStep(1, currentStep.id, nextStep.id)) {
+    const nameValidation = await checkName(value)
+
+    value = nameValidation.newValue
+    stepHasError = stepHasError || nameValidation.stepHasError
+  }
+
+  if (wizard.isValidateForStep(2, currentStep.id, nextStep.id)) {
+    const validation = await checkStorage(value)
+
+    value = validation.newValue
+    stepHasError = stepHasError || validation.stepHasError
+  }
+
+  if (wizard.isValidateForStep(3, currentStep.id, nextStep.id)) {
+    const validation = checkDisks(value)
+
+    value = validation.newValue
+    stepHasError = stepHasError || validation.stepHasError
+  }
+
+  wizard.setLoader(false)
+
+  return {
+    newValue: value,
+    stepHasError,
+    stepShouldStop,
+  }
+}
+
+const checkName = async (
+  value: UI_I_WizardStep[]
+): Promise<UI_I_ValidationReturn> => {
+  let stepHasError = false
+
+  return new Promise((resolve) => {
+    nameFormSubmit.value = (isValid: boolean): void => {
+      if (!isValid) {
+        stepHasError = wizard.setValidation(1, 'name', {
+          fieldMessage: 'aaa',
+          alertMessage: 'aaa',
+        })
+      } else if (wizard.hasMessage(1, 'name')) {
+        value = wizard.removeValidation(1, 'name', value)
+      }
+
+      resolve({
+        stepHasError,
+        newValue: value,
+      })
+      nameFormSubmit.value = null
+    }
+  })
+}
+
+const checkStorage = async (
+  value: UI_I_WizardStep[]
+): Promise<UI_I_ValidationReturn> => {
+  let stepHasError = false
+
+  return new Promise((resolve) => {
+    storageSubmit.value = (isValid: boolean): void => {
+      if (!isValid) {
+        stepHasError = wizard.setValidation(2, 'storage', {
+          fieldMessage: 'aaa',
+          alertMessage: 'aaa',
+        })
+      } else if (wizard.hasMessage(2, 'storage')) {
+        value = wizard.removeValidation(2, 'storage', value)
+      }
+
+      resolve({
+        stepHasError,
+        newValue: value,
+      })
+      storageSubmit.value = null
+    }
+  })
+}
+
+const checkDisks = (value: UI_I_WizardStep[]): UI_I_ValidationReturn => {
+  let stepHasError = false
+
+  const isValidStores = !!model.value?.pvm.disk_devices.length
+  if (!isValidStores) {
+    stepHasError = wizard.setValidation(3, 'disk_devices', {
+      fieldMessage: localization.value.common.diskIsRequired,
+      alertMessage: localization.value.common.diskIsRequired,
+    })
+    showValidationErrors([localization.value.common.diskIsRequired])
+  } else if (wizard.hasMessage(3, 'disk_devices')) {
+    value = wizard.removeValidation(3, 'disk_devices', value)
+    onRemoveValidationErrors()
+  }
+
+  return {
+    stepHasError,
+    newValue: value,
+  }
+}
+
+const getDatastoreTableFunc = async (
+    payload: UI_I_TablePayload
+): Promise<void> => {
+  console.log(payload, 111);
+  emits('get-datastore', model.value.bucket)
+}
+
+const selectedStorageName = ref<string>('')
+const onChangeStorage = (storage: UI_I_DatastoreTableItem | null): void => {
+  if (!storage) return
+  selectedStorageName.value = storage.name
+  model.value.pvm.storage = {
+    id: storage.id,
+    folder: '',
+  }
+}
+
+const onCheckName = async (
+  name: string,
+  cb: (error: API_UI_I_Error) => void
+): Promise<void> => {
+  emits('check-name', { name, cb })
+}
+
+const isLoading = ref<boolean>(true)
+// В Сфере и Прокураторе одно и тоже
+const getPvm = async (): Promise<void> => {
+  await $store.dispatch('backup/A_GET_PVM', {
+    target: model.value.backup_storage,
+    bucketId: model.value.bucket, // TODO bucket поменять на vm так как это сейчас vm
+    backupId: model.value.backup,
+  })
+
+  model.value.pvm = useDeepCopy($store.getters['backup/getPvm'])
+  isLoading.value = false
+}
+getPvm()
+
+const readyToCompleteInfo = computed<UI_I_TableInfoItem[]>(() => {
+  const result = []
+
+  switch (model.value.restore_code) {
+    case 1:
+    case 2:
+      result.push({
+        label: localization.value.common.backup,
+        value: model.value.backup,
+      })
+      break
+    case 3:
+      result.push({
+        label: localization.value.common.vmName,
+        value: model.value.pvm.name,
+      })
+
+      // Datastores
+      result.push({
+        label: localization.value.common.datastore,
+        value: selectedStorageName.value,
+      })
+
+      // Disks
+      model.value.pvm.disk_devices.forEach((disk_device, i) => {
+        if (!disk_device.source) return
+
+        result.push({
+          label: `${localization.value.common.disk} ${i}`,
+          value: disk_device.source,
+        })
+      })
+
+      // Networks
+      model.value.pvm.network_devices.forEach((network) => {
+        result.push({
+          label: localization.value.common.network,
+          value: network.network,
+        })
+      })
+      break
+    // case 1:
+    //   result.push({
+    //     label: localization.value.common.vmName,
+    //     value: model.value.pvm.name,
+    //   })
+    //   break
+  }
+
+  return result
+})
+
+const errors = ref<string[]>([])
+const showValidationErrors = (data: string[]): void => {
+  errors.value = data
+}
+const onRemoveValidationErrors = (): void => {
+  errors.value = []
+}
+
+const onFinish = (): void => {
+  emits('finish')
+}
+const onHideModal = (): void => {
+  emits('hide')
+}
+
+const onRestore = (): void => {
+  if (model.value.restore_code === 2) {
+    isShowConfirm.value = true
+  } else {
+    onFinish()
+  }
+}
+
+const isShowConfirm = ref<boolean>(false)
+
+const onGetNetworks = (hostId: string): void => {
+  emits('get-networks', hostId)
+}
+</script>
+
+<style scoped lang="scss">
+:deep(.modal-body) {
+  display: flex;
+  flex-direction: column;
+}
+.loader-wrap {
+  background-color: rgba(0, 0, 0, 0.3);
+  z-index: var(--z-fixed);
+}
+</style>

package/components/common/pages/backups/modals/restore/disks/Disks.vue

@@ -0,0 +1,28 @@
+<template>
+  <div class="disks h-full">
+    <common-pages-backups-modals-restore-disks-table-view
+      v-model:selected="model.pvm.disk_devices"
+      :data-table="disks"
+      :total-items="disks.length"
+      :total-pages="1"
+    />
+  </div>
+</template>
+
+<script lang="ts" setup>
+// import type { I_RestoreForm } from '~/components/common/pages/backups/modals/lib/models/interfaces'
+import type { UI_I_Pvm } from '~/lib/models/store/vm/interfaces'
+
+const model = defineModel<I_RestoreForm>({ required: true })
+
+const { $store } = useNuxtApp()
+
+const disks = computed<UI_I_Pvm['disk_devices']>(
+  () =>
+    $store.getters['backup/getPvm']?.disk_devices.filter(
+      (disk: UI_I_Pvm['disk_devices'][0]) => disk.source
+    ) || []
+)
+</script>
+
+<style lang="scss" scoped></style>