Examples with VirtualMachineRelocateDiskMoveOptions com.vmware.vim25.VirtualMachineRelocateDiskMoveOptions used on opensource projects

Example 1 with VirtualMachineRelocateDiskMoveOptions

use of com.vmware.vim25.VirtualMachineRelocateDiskMoveOptions in project CloudStack-archive by CloudStack-extras.

the class VirtualMachineMO method createLinkedClone.

public boolean createLinkedClone(String cloneName, ManagedObjectReference morBaseSnapshot, ManagedObjectReference morFolder, ManagedObjectReference morResourcePool, ManagedObjectReference morDs) throws Exception {
    assert (morBaseSnapshot != null);
    assert (morFolder != null);
    assert (morResourcePool != null);
    assert (morDs != null);
    VirtualDisk[] independentDisks = getAllIndependentDiskDevice();
    VirtualMachineRelocateSpec rSpec = new VirtualMachineRelocateSpec();
    if (independentDisks.length > 0) {
        VirtualMachineRelocateSpecDiskLocator[] diskLocator = new VirtualMachineRelocateSpecDiskLocator[independentDisks.length];
        for (int i = 0; i < diskLocator.length; i++) {
            diskLocator[i] = new VirtualMachineRelocateSpecDiskLocator();
            diskLocator[i].setDatastore(morDs);
            diskLocator[i].setDiskId(independentDisks[i].getKey());
            diskLocator[i].setDiskMoveType(VirtualMachineRelocateDiskMoveOptions._moveAllDiskBackingsAndDisallowSharing);
        }
        rSpec.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions._createNewChildDiskBacking);
        rSpec.setDisk(diskLocator);
    } else {
        rSpec.setDiskMoveType(VirtualMachineRelocateDiskMoveOptions._createNewChildDiskBacking);
    }
    rSpec.setPool(morResourcePool);
    VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();
    cloneSpec.setPowerOn(false);
    cloneSpec.setTemplate(false);
    cloneSpec.setLocation(rSpec);
    cloneSpec.setSnapshot(morBaseSnapshot);
    ManagedObjectReference morTask = _context.getService().cloneVM_Task(_mor, morFolder, cloneName, cloneSpec);
    String result = _context.getServiceUtil().waitForTask(morTask);
    if (result.equals("sucess")) {
        _context.waitForTaskProgressDone(morTask);
        return true;
    } else {
        s_logger.error("VMware cloneVM_Task failed due to " + TaskMO.getTaskFailureInfo(_context, morTask));
    }
    return false;
}

Example 2 with VirtualMachineRelocateDiskMoveOptions

use of com.vmware.vim25.VirtualMachineRelocateDiskMoveOptions in project photon-model by vmware.

the class InstanceClient method cloneOvfBasedTemplate.

private ManagedObjectReference cloneOvfBasedTemplate(ManagedObjectReference vmTempl, ManagedObjectReference datastore, ManagedObjectReference folder, ManagedObjectReference resourcePool, List<VirtualMachineDefinedProfileSpec> pbmSpec) throws Exception {
    String vmName = this.ctx.child.name;
    Map<String, Object> props = this.get.entityProps(vmTempl, VimPath.vm_summary_config_numCpu, VimPath.vm_summary_config_memorySizeMB, VimPath.vm_snapshot, VimPath.vm_config_hardware_device, VimPath.vm_config_vAppConfig_property);
    VirtualMachineSnapshotInfo snapshot = (VirtualMachineSnapshotInfo) props.get(VimPath.vm_snapshot);
    ArrayOfVirtualDevice devices = (ArrayOfVirtualDevice) props.get(VimPath.vm_config_hardware_device);
    VirtualDisk vd = devices.getVirtualDevice().stream().filter(d -> d instanceof VirtualDisk).map(d -> (VirtualDisk) d).findFirst().orElse(null);
    VirtualSCSIController scsiController = getFirstScsiController(devices);
    Integer[] scsiUnit = findFreeScsiUnit(scsiController, devices.getVirtualDevice());
    VirtualMachineRelocateDiskMoveOptions diskMoveOption = computeDiskMoveType();
    boolean customizeImageDisk = false;
    List<VirtualDeviceConfigSpec> newDisks = new ArrayList<>();
    VirtualMachineRelocateSpecDiskLocator bootDiskLocator = null;
    List<VirtualDisk> vDisks = null;
    if (this.bootDisk != null) {
        if (vd == null) {
            String datastoreName = this.get.entityProp(datastore, VimPath.ds_summary_name);
            String path = makePathToVmdkFile("ephemeral_disk", vmName);
            String diskName = String.format(VM_PATH_FORMAT, datastoreName, path);
            VirtualDeviceConfigSpec hdd = createHdd(scsiController.getKey(), scsiUnit[0], this.bootDisk, diskName, datastore, pbmSpec);
            newDisks.add(hdd);
        } else {
            // strategy
            if (this.imageDisks != null && !this.imageDisks.isEmpty()) {
                vDisks = devices.getVirtualDevice().stream().filter(d -> d instanceof VirtualDisk).map(d -> (VirtualDisk) d).filter(d -> {
                    DiskStateExpanded ds = findMatchingImageDiskState(d, this.imageDisks);
                    return toKb(ds.capacityMBytes) > d.getCapacityInKB() || ds.customProperties != null;
                }).collect(Collectors.toList());
                if (vDisks.size() > 0) {
                    diskMoveOption = VirtualMachineRelocateDiskMoveOptions.MOVE_ALL_DISK_BACKINGS_AND_DISALLOW_SHARING;
                    logger.warn("Changing clone strategy to MOVE_ALL_DISK_BACKINGS_AND_DISALLOW_SHARING, as there is disk resize requested");
                    customizeImageDisk = true;
                    bootDiskLocator = setProvisioningType(vDisks.get(0), datastore, pbmSpec);
                }
            }
        }
    }
    VirtualCdrom vcd = devices.getVirtualDevice().stream().filter(d -> d instanceof VirtualCdrom).map(d -> (VirtualCdrom) d).findFirst().orElse(null);
    // add a cdrom so that ovf transport works
    if (vcd == null) {
        VirtualDevice ideController = getFirstIdeController(devices);
        int ideUnit = findFreeUnit(ideController, devices.getVirtualDevice());
        VirtualDeviceConfigSpec cdrom = createCdrom(ideController, ideUnit);
        newDisks.add(cdrom);
    } else {
        VirtualDeviceConfigSpec cdrom = reconfigureCdrom(vcd);
        newDisks.add(cdrom);
    }
    VirtualMachineConfigSpec spec = new VirtualMachineConfigSpec();
    // even though this is a clone, hw config from the compute resource
    // is takes precedence
    spec.setNumCPUs((int) this.ctx.child.description.cpuCount);
    spec.setMemoryMB(toMemoryMb(this.ctx.child.description.totalMemoryBytes));
    String gt = CustomProperties.of(this.ctx.child).getString(CustomProperties.GUEST_ID, null);
    if (gt != null) {
        spec.setGuestId(gt);
    }
    // set ovf environment
    ArrayOfVAppPropertyInfo infos = (ArrayOfVAppPropertyInfo) props.get(// this.get.entityProp(vmTempl,
    VimPath.vm_config_vAppConfig_property);
    // VimPath.vm_config_vAppConfig_property);
    populateVAppProperties(spec, infos);
    populateCloudConfig(spec, infos);
    recordTimestamp(spec.getExtraConfig());
    // set the maximum snapshot limit if specified
    final String snapshotLimit = CustomProperties.of(this.ctx.child).getString(CustomProperties.SNAPSHOT_MAXIMUM_LIMIT);
    recordSnapshotLimit(spec.getExtraConfig(), snapshotLimit);
    // add disks one at a time
    for (VirtualDeviceConfigSpec newDisk : newDisks) {
        spec.getDeviceChange().add(newDisk);
    }
    // configure network
    VirtualPCIController pci = getFirstPciController(devices);
    for (NetworkInterfaceStateWithDetails nicWithDetails : this.ctx.nics) {
        VirtualDevice nic = createNic(nicWithDetails, pci.getControllerKey());
        addDeviceToVm(spec, nic);
    }
    // remove any networks from the template
    devices.getVirtualDevice().stream().filter(d -> VirtualEthernetCard.class.isAssignableFrom(d.getClass())).forEach(d -> addRemoveDeviceFromVm(spec, d));
    VirtualMachineRelocateSpec relocSpec = new VirtualMachineRelocateSpec();
    if (pbmSpec != null) {
        pbmSpec.stream().forEach(sp -> {
            relocSpec.getProfile().add(sp);
        });
    }
    relocSpec.setDatastore(datastore);
    relocSpec.setFolder(folder);
    relocSpec.setPool(resourcePool);
    relocSpec.setDiskMoveType(diskMoveOption.value());
    VirtualMachineCloneSpec cloneSpec = new VirtualMachineCloneSpec();
    cloneSpec.setLocation(relocSpec);
    cloneSpec.setPowerOn(false);
    cloneSpec.setTemplate(false);
    if (snapshot != null) {
        cloneSpec.setSnapshot(snapshot.getCurrentSnapshot());
    }
    cloneSpec.setConfig(spec);
    if (bootDiskLocator != null) {
        cloneSpec.getLocation().getDisk().add(bootDiskLocator);
    }
    ManagedObjectReference cloneTask = getVimPort().cloneVMTask(vmTempl, folder, vmName, cloneSpec);
    TaskInfo info = waitTaskEnd(cloneTask);
    if (info.getState() == TaskInfoState.ERROR) {
        return VimUtils.rethrow(info.getError());
    }
    ManagedObjectReference vmMoref = (ManagedObjectReference) info.getResult();
    // Apply boot disk customization if any, if done through full clone.
    if (customizeImageDisk) {
        ArrayOfVirtualDevice virtualDevices = this.get.entityProp(vmMoref, VimPath.vm_config_hardware_device);
        reconfigureBootDisk(vmMoref, getCustomizationConfigSpecs(virtualDevices, this.imageDisks));
    }
    return vmMoref;
}