Examples with UserVmVO com.cloud.vm.UserVmVO used on opensource projects

Example 46 with UserVmVO

use of com.cloud.vm.UserVmVO in project cloudstack by apache.

the class VolumeApiServiceImpl method createVolumeFromSnapshot.

protected VolumeVO createVolumeFromSnapshot(VolumeVO volume, long snapshotId, Long vmId) throws StorageUnavailableException {
    VolumeInfo createdVolume = null;
    SnapshotVO snapshot = _snapshotDao.findById(snapshotId);
    snapshot.getVolumeId();
    UserVmVO vm = null;
    if (vmId != null) {
        vm = _userVmDao.findById(vmId);
    }
    // sync old snapshots to region store if necessary
    createdVolume = _volumeMgr.createVolumeFromSnapshot(volume, snapshot, vm);
    VolumeVO volumeVo = _volsDao.findById(createdVolume.getId());
    UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, createdVolume.getAccountId(), createdVolume.getDataCenterId(), createdVolume.getId(), createdVolume.getName(), createdVolume.getDiskOfferingId(), null, createdVolume.getSize(), Volume.class.getName(), createdVolume.getUuid(), volumeVo.isDisplayVolume());
    return volumeVo;
}

Example 47 with UserVmVO

use of com.cloud.vm.UserVmVO in project cloudstack by apache.

the class VolumeApiServiceImpl method attachVolumeToVM.

public Volume attachVolumeToVM(Long vmId, Long volumeId, Long deviceId) {
    Account caller = CallContext.current().getCallingAccount();
    // Check that the volume ID is valid
    VolumeInfo volumeToAttach = volFactory.getVolume(volumeId);
    // Check that the volume is a data volume
    if (volumeToAttach == null || !(volumeToAttach.getVolumeType() == Volume.Type.DATADISK || volumeToAttach.getVolumeType() == Volume.Type.ROOT)) {
        throw new InvalidParameterValueException("Please specify a volume with the valid type: " + Volume.Type.ROOT.toString() + " or " + Volume.Type.DATADISK.toString());
    }
    // Check that the volume is not currently attached to any VM
    if (volumeToAttach.getInstanceId() != null) {
        throw new InvalidParameterValueException("Please specify a volume that is not attached to any VM.");
    }
    // Check that the volume is not destroyed
    if (volumeToAttach.getState() == Volume.State.Destroy) {
        throw new InvalidParameterValueException("Please specify a volume that is not destroyed.");
    }
    // Check that the virtual machine ID is valid and it's a user vm
    UserVmVO vm = _userVmDao.findById(vmId);
    if (vm == null || vm.getType() != VirtualMachine.Type.User) {
        throw new InvalidParameterValueException("Please specify a valid User VM.");
    }
    // Check that the VM is in the correct state
    if (vm.getState() != State.Running && vm.getState() != State.Stopped) {
        throw new InvalidParameterValueException("Please specify a VM that is either running or stopped.");
    }
    // Check that the VM and the volume are in the same zone
    if (vm.getDataCenterId() != volumeToAttach.getDataCenterId()) {
        throw new InvalidParameterValueException("Please specify a VM that is in the same zone as the volume.");
    }
    // Check that the device ID is valid
    if (deviceId != null) {
        // validate ROOT volume type
        if (deviceId.longValue() == 0) {
            validateRootVolumeDetachAttach(_volsDao.findById(volumeToAttach.getId()), vm);
            // vm shouldn't have any volume with deviceId 0
            if (!_volsDao.findByInstanceAndDeviceId(vm.getId(), 0).isEmpty()) {
                throw new InvalidParameterValueException("Vm already has root volume attached to it");
            }
            // volume can't be in Uploaded state
            if (volumeToAttach.getState() == Volume.State.Uploaded) {
                throw new InvalidParameterValueException("No support for Root volume attach in state " + Volume.State.Uploaded);
            }
        }
    }
    // that supported by hypervisor
    if (deviceId == null || deviceId.longValue() != 0) {
        List<VolumeVO> existingDataVolumes = _volsDao.findByInstanceAndType(vmId, Volume.Type.DATADISK);
        int maxAttachableDataVolumesSupported = getMaxDataVolumesSupported(vm);
        if (existingDataVolumes.size() >= maxAttachableDataVolumesSupported) {
            throw new InvalidParameterValueException("The specified VM already has the maximum number of data disks (" + maxAttachableDataVolumesSupported + ") attached. Please specify another VM.");
        }
    }
    // If local storage is disabled then attaching a volume with local disk
    // offering not allowed
    DataCenterVO dataCenter = _dcDao.findById(volumeToAttach.getDataCenterId());
    if (!dataCenter.isLocalStorageEnabled()) {
        DiskOfferingVO diskOffering = _diskOfferingDao.findById(volumeToAttach.getDiskOfferingId());
        if (diskOffering.isUseLocalStorage()) {
            throw new InvalidParameterValueException("Zone is not configured to use local storage but volume's disk offering " + diskOffering.getName() + " uses it");
        }
    }
    // if target VM has associated VM snapshots
    List<VMSnapshotVO> vmSnapshots = _vmSnapshotDao.findByVm(vmId);
    if (vmSnapshots.size() > 0) {
        throw new InvalidParameterValueException("Unable to attach volume, please specify a VM that does not have VM snapshots");
    }
    // if target VM has backups
    if (vm.getBackupOfferingId() != null || vm.getBackupVolumeList().size() > 0) {
        throw new InvalidParameterValueException("Unable to attach volume, please specify a VM that does not have any backups");
    }
    // permission check
    _accountMgr.checkAccess(caller, null, true, volumeToAttach, vm);
    if (!(Volume.State.Allocated.equals(volumeToAttach.getState()) || Volume.State.Ready.equals(volumeToAttach.getState()) || Volume.State.Uploaded.equals(volumeToAttach.getState()))) {
        throw new InvalidParameterValueException("Volume state must be in Allocated, Ready or in Uploaded state");
    }
    Account owner = _accountDao.findById(volumeToAttach.getAccountId());
    if (!(volumeToAttach.getState() == Volume.State.Allocated || volumeToAttach.getState() == Volume.State.Ready)) {
        try {
            _resourceLimitMgr.checkResourceLimit(owner, ResourceType.primary_storage, volumeToAttach.getSize());
        } catch (ResourceAllocationException e) {
            s_logger.error("primary storage resource limit check failed", e);
            throw new InvalidParameterValueException(e.getMessage());
        }
    }
    HypervisorType rootDiskHyperType = vm.getHypervisorType();
    HypervisorType volumeToAttachHyperType = _volsDao.getHypervisorType(volumeToAttach.getId());
    StoragePoolVO volumeToAttachStoragePool = _storagePoolDao.findById(volumeToAttach.getPoolId());
    // only perform this check if the volume's storage pool is not null and not managed
    if (volumeToAttachStoragePool != null && !volumeToAttachStoragePool.isManaged()) {
        if (volumeToAttachHyperType != HypervisorType.None && rootDiskHyperType != volumeToAttachHyperType) {
            throw new InvalidParameterValueException("Can't attach a volume created by: " + volumeToAttachHyperType + " to a " + rootDiskHyperType + " vm");
        }
    }
    AsyncJobExecutionContext asyncExecutionContext = AsyncJobExecutionContext.getCurrentExecutionContext();
    if (asyncExecutionContext != null) {
        AsyncJob job = asyncExecutionContext.getJob();
        if (s_logger.isInfoEnabled()) {
            s_logger.info("Trying to attaching volume " + volumeId + " to vm instance:" + vm.getId() + ", update async job-" + job.getId() + " progress status");
        }
        _jobMgr.updateAsyncJobAttachment(job.getId(), "Volume", volumeId);
    }
    AsyncJobExecutionContext jobContext = AsyncJobExecutionContext.getCurrentExecutionContext();
    if (jobContext.isJobDispatchedBy(VmWorkConstants.VM_WORK_JOB_DISPATCHER)) {
        // avoid re-entrance
        VmWorkJobVO placeHolder = null;
        placeHolder = createPlaceHolderWork(vmId);
        try {
            return orchestrateAttachVolumeToVM(vmId, volumeId, deviceId);
        } finally {
            _workJobDao.expunge(placeHolder.getId());
        }
    } else {
        Outcome<Volume> outcome = attachVolumeToVmThroughJobQueue(vmId, volumeId, deviceId);
        Volume vol = null;
        try {
            outcome.get();
        } catch (InterruptedException e) {
            throw new RuntimeException("Operation is interrupted", e);
        } catch (java.util.concurrent.ExecutionException e) {
            throw new RuntimeException("Execution excetion", e);
        }
        Object jobResult = _jobMgr.unmarshallResultObject(outcome.getJob());
        if (jobResult != null) {
            if (jobResult instanceof ConcurrentOperationException) {
                throw (ConcurrentOperationException) jobResult;
            } else if (jobResult instanceof InvalidParameterValueException) {
                throw (InvalidParameterValueException) jobResult;
            } else if (jobResult instanceof RuntimeException) {
                throw (RuntimeException) jobResult;
            } else if (jobResult instanceof Throwable) {
                throw new RuntimeException("Unexpected exception", (Throwable) jobResult);
            } else if (jobResult instanceof Long) {
                vol = _volsDao.findById((Long) jobResult);
            }
        }
        return vol;
    }
}

Example 48 with UserVmVO

use of com.cloud.vm.UserVmVO in project cloudstack by apache.

the class VMSnapshotManagerImpl method createVMSnapshot.

@Override
@ActionEvent(eventType = EventTypes.EVENT_VM_SNAPSHOT_CREATE, eventDescription = "creating VM snapshot", async = true)
public VMSnapshot createVMSnapshot(Long vmId, Long vmSnapshotId, Boolean quiescevm) {
    UserVmVO userVm = _userVMDao.findById(vmId);
    if (userVm == null) {
        throw new InvalidParameterValueException("Create vm to snapshot failed due to vm: " + vmId + " is not found");
    }
    VMSnapshotVO vmSnapshot = _vmSnapshotDao.findById(vmSnapshotId);
    if (vmSnapshot == null) {
        throw new CloudRuntimeException("VM snapshot id: " + vmSnapshotId + " can not be found");
    }
    // serialize VM operation
    AsyncJobExecutionContext jobContext = AsyncJobExecutionContext.getCurrentExecutionContext();
    if (jobContext.isJobDispatchedBy(VmWorkConstants.VM_WORK_JOB_DISPATCHER)) {
        // avoid re-entrance
        VmWorkJobVO placeHolder = null;
        placeHolder = createPlaceHolderWork(vmId);
        try {
            return orchestrateCreateVMSnapshot(vmId, vmSnapshotId, quiescevm);
        } finally {
            _workJobDao.expunge(placeHolder.getId());
        }
    } else {
        Outcome<VMSnapshot> outcome = createVMSnapshotThroughJobQueue(vmId, vmSnapshotId, quiescevm);
        VMSnapshot result = null;
        try {
            result = outcome.get();
        } catch (InterruptedException e) {
            throw new RuntimeException("Operation is interrupted", e);
        } catch (java.util.concurrent.ExecutionException e) {
            throw new RuntimeException("Execution excetion", e);
        }
        Object jobResult = _jobMgr.unmarshallResultObject(outcome.getJob());
        if (jobResult != null) {
            if (jobResult instanceof ConcurrentOperationException)
                throw (ConcurrentOperationException) jobResult;
            else if (jobResult instanceof Throwable)
                throw new RuntimeException("Unexpected exception", (Throwable) jobResult);
        }
        return result;
    }
}

Example 49 with UserVmVO

use of com.cloud.vm.UserVmVO in project cloudstack by apache.

the class VMSnapshotManagerImpl method getVMBySnapshotId.

@Override
public VirtualMachine getVMBySnapshotId(Long id) {
    VMSnapshotVO vmSnapshot = _vmSnapshotDao.findById(id);
    if (vmSnapshot == null) {
        throw new InvalidParameterValueException("unable to find the vm snapshot with id " + id);
    }
    Long vmId = vmSnapshot.getVmId();
    UserVmVO vm = _userVMDao.findById(vmId);
    return vm;
}

Example 50 with UserVmVO

use of com.cloud.vm.UserVmVO in project cloudstack by apache.

the class VMSnapshotManagerImpl method allocVMSnapshot.

@Override
public VMSnapshot allocVMSnapshot(Long vmId, String vsDisplayName, String vsDescription, Boolean snapshotMemory) throws ResourceAllocationException {
    Account caller = getCaller();
    // check if VM exists
    UserVmVO userVmVo = _userVMDao.findById(vmId);
    if (userVmVo == null) {
        throw new InvalidParameterValueException("Creating VM snapshot failed due to VM:" + vmId + " is a system VM or does not exist");
    }
    // VM snapshot with memory is not supported for VGPU Vms
    if (snapshotMemory && _serviceOfferingDetailsDao.findDetail(userVmVo.getServiceOfferingId(), GPU.Keys.vgpuType.toString()) != null) {
        throw new InvalidParameterValueException("VM snapshot with MEMORY is not supported for vGPU enabled VMs.");
    }
    // check hypervisor capabilities
    if (!_hypervisorCapabilitiesDao.isVmSnapshotEnabled(userVmVo.getHypervisorType(), "default"))
        throw new InvalidParameterValueException("VM snapshot is not enabled for hypervisor type: " + userVmVo.getHypervisorType());
    // parameter length check
    if (vsDisplayName != null && vsDisplayName.length() > 255)
        throw new InvalidParameterValueException("Creating VM snapshot failed due to length of VM snapshot vsDisplayName should not exceed 255");
    if (vsDescription != null && vsDescription.length() > 255)
        throw new InvalidParameterValueException("Creating VM snapshot failed due to length of VM snapshot vsDescription should not exceed 255");
    // VM snapshot display name must be unique for a VM
    String timeString = DateUtil.getDateDisplayString(DateUtil.GMT_TIMEZONE, new Date(), DateUtil.YYYYMMDD_FORMAT);
    String vmSnapshotName = userVmVo.getInstanceName() + "_VS_" + timeString;
    if (vsDisplayName == null) {
        vsDisplayName = vmSnapshotName;
    }
    if (_vmSnapshotDao.findByName(vmId, vsDisplayName) != null) {
        throw new InvalidParameterValueException("Creating VM snapshot failed due to VM snapshot with name" + vsDisplayName + "  already exists");
    }
    // check VM state
    if (userVmVo.getState() != VirtualMachine.State.Running && userVmVo.getState() != VirtualMachine.State.Stopped) {
        throw new InvalidParameterValueException("Creating vm snapshot failed due to VM:" + vmId + " is not in the running or Stopped state");
    }
    if (snapshotMemory && userVmVo.getState() != VirtualMachine.State.Running) {
        throw new InvalidParameterValueException("Can not snapshot memory when VM is not in Running state");
    }
    List<VolumeVO> rootVolumes = _volumeDao.findReadyRootVolumesByInstance(userVmVo.getId());
    if (rootVolumes == null || rootVolumes.isEmpty()) {
        throw new CloudRuntimeException("Unable to find root volume for the user vm:" + userVmVo.getUuid());
    }
    VolumeVO rootVolume = rootVolumes.get(0);
    StoragePoolVO rootVolumePool = _storagePoolDao.findById(rootVolume.getPoolId());
    if (rootVolumePool == null) {
        throw new CloudRuntimeException("Unable to find root volume storage pool for the user vm:" + userVmVo.getUuid());
    }
    // for KVM, only allow snapshot with memory when VM is in running state
    if (userVmVo.getHypervisorType() == HypervisorType.KVM) {
        if (rootVolumePool.getPoolType() != Storage.StoragePoolType.PowerFlex) {
            if (userVmVo.getState() == State.Running && !snapshotMemory) {
                throw new InvalidParameterValueException("KVM VM does not allow to take a disk-only snapshot when VM is in running state");
            }
        } else {
            if (snapshotMemory) {
                throw new InvalidParameterValueException("Can not snapshot memory for PowerFlex storage pool");
            }
            // All volumes should be on the same PowerFlex storage pool for VM Snapshot
            if (!isVolumesOfUserVmOnSameStoragePool(userVmVo.getId(), rootVolumePool.getId())) {
                throw new InvalidParameterValueException("All volumes of the VM: " + userVmVo.getUuid() + " should be on the same PowerFlex storage pool");
            }
        }
    }
    // check access
    _accountMgr.checkAccess(caller, null, true, userVmVo);
    // check max snapshot limit for per VM
    if (_vmSnapshotDao.findByVm(vmId).size() >= _vmSnapshotMax) {
        throw new CloudRuntimeException("Creating vm snapshot failed due to a VM can just have : " + _vmSnapshotMax + " VM snapshots. Please delete old ones");
    }
    // check if there are active volume snapshots tasks
    List<VolumeVO> listVolumes = _volumeDao.findByInstance(vmId);
    for (VolumeVO volume : listVolumes) {
        List<SnapshotVO> activeSnapshots = _snapshotDao.listByInstanceId(volume.getInstanceId(), Snapshot.State.Creating, Snapshot.State.CreatedOnPrimary, Snapshot.State.BackingUp);
        if (activeSnapshots.size() > 0) {
            throw new CloudRuntimeException("There is other active volume snapshot tasks on the instance to which the volume is attached, please try again later.");
        }
        if (userVmVo.getHypervisorType() == HypervisorType.KVM) {
            if (volume.getPoolType() != Storage.StoragePoolType.PowerFlex) {
                if (volume.getFormat() != ImageFormat.QCOW2) {
                    throw new CloudRuntimeException("We only support create vm snapshots from vm with QCOW2 image");
                }
            } else if (volume.getFormat() != ImageFormat.RAW) {
                throw new CloudRuntimeException("Only support create vm snapshots for volumes on PowerFlex with RAW image");
            }
        }
    }
    // check if there are other active VM snapshot tasks
    if (hasActiveVMSnapshotTasks(vmId)) {
        throw new CloudRuntimeException("There is other active vm snapshot tasks on the instance, please try again later");
    }
    VMSnapshot.Type vmSnapshotType = VMSnapshot.Type.Disk;
    if (snapshotMemory && userVmVo.getState() == VirtualMachine.State.Running)
        vmSnapshotType = VMSnapshot.Type.DiskAndMemory;
    if (rootVolumePool.getPoolType() == Storage.StoragePoolType.PowerFlex) {
        vmSnapshotType = VMSnapshot.Type.Disk;
    }
    try {
        return createAndPersistVMSnapshot(userVmVo, vsDescription, vmSnapshotName, vsDisplayName, vmSnapshotType);
    } catch (Exception e) {
        String msg = e.getMessage();
        s_logger.error("Create vm snapshot record failed for vm: " + vmId + " due to: " + msg);
    }
    return null;
}