atrocitytheme · atrocitytheme · Jul 15, 2021 · Jun 7, 2021 · Jun 10, 2021 · Jun 16, 2021
diff --git a/api/src/main/java/com/cloud/event/EventTypes.java b/api/src/main/java/com/cloud/event/EventTypes.java
@@ -105,6 +105,7 @@ public class EventTypes {
    public static final String EVENT_VM_IMPORT = "VM.IMPORT";
    public static final String EVENT_VM_UNMANAGE = "VM.UNMANAGE";
    public static final String EVENT_VM_RECOVER = "VM.RECOVER";
+    public static final String EVENT_VM_CLONE = "VM.CLONE";

    // Domain Router
    public static final String EVENT_ROUTER_CREATE = "ROUTER.CREATE";

diff --git a/api/src/main/java/com/cloud/network/NetworkModel.java b/api/src/main/java/com/cloud/network/NetworkModel.java
@@ -107,6 +107,10 @@ public interface NetworkModel {

    List<? extends Network> listNetworksUsedByVm(long vmId, boolean isSystem);

+    default List<Long> listNetworksUsedByVm(long vmId) {
+        throw new UnsupportedOperationException();
+    }
+
    Nic getNicInNetwork(long vmId, long networkId);

    List<? extends Nic> getNicsForTraffic(long vmId, TrafficType type);

diff --git a/api/src/main/java/com/cloud/storage/VolumeApiService.java b/api/src/main/java/com/cloud/storage/VolumeApiService.java
@@ -21,6 +21,8 @@
 import java.net.MalformedURLException;
 import java.util.Map;

+import com.cloud.exception.StorageUnavailableException;
+import org.apache.cloudstack.api.command.user.vm.CloneVMCmd;
 import org.apache.cloudstack.api.command.user.volume.AttachVolumeCmd;
 import org.apache.cloudstack.api.command.user.volume.CreateVolumeCmd;
 import org.apache.cloudstack.api.command.user.volume.DetachVolumeCmd;
@@ -92,6 +94,8 @@ public interface VolumeApiService {

    Volume detachVolumeViaDestroyVM(long vmId, long volumeId);

+    Volume cloneDataVolume(CloneVMCmd cmd, long snapshotId, Volume volume) throws StorageUnavailableException;
+
    Volume detachVolumeFromVM(DetachVolumeCmd cmd);

    Snapshot takeSnapshot(Long volumeId, Long policyId, Long snapshotId, Account account, boolean quiescevm, Snapshot.LocationType locationType, boolean asyncBackup, Map<String, String> tags)
@@ -101,6 +105,8 @@ Snapshot takeSnapshot(Long volumeId, Long policyId, Long snapshotId, Account acc

    Volume updateVolume(long volumeId, String path, String state, Long storageId, Boolean displayVolume, String customId, long owner, String chainInfo);

+    Volume attachVolumeToVm(CloneVMCmd cmd, Long volumeId, Long deviceId);
+
    /**
     * Extracts the volume to a particular location.
     *

diff --git a/api/src/main/java/com/cloud/template/TemplateApiService.java b/api/src/main/java/com/cloud/template/TemplateApiService.java
@@ -20,6 +20,7 @@
 import java.net.URISyntaxException;
 import java.util.List;

+import com.cloud.storage.VolumeApiService;
 import org.apache.cloudstack.api.BaseListTemplateOrIsoPermissionsCmd;
 import org.apache.cloudstack.api.BaseUpdateTemplateOrIsoPermissionsCmd;
 import org.apache.cloudstack.api.command.user.iso.DeleteIsoCmd;
@@ -40,6 +41,7 @@
 import com.cloud.exception.StorageUnavailableException;
 import com.cloud.user.Account;
 import com.cloud.utils.exception.CloudRuntimeException;
+import org.apache.cloudstack.api.command.user.vm.CloneVMCmd;
 import org.apache.cloudstack.api.response.GetUploadParamsResponse;

 public interface TemplateApiService {
@@ -99,6 +101,13 @@ public interface TemplateApiService {

    boolean updateTemplateOrIsoPermissions(BaseUpdateTemplateOrIsoPermissionsCmd cmd);

+    /**
+     * create a template record for later usage of creating a real template by createPrivateTemplate
+     * */
+    VirtualMachineTemplate createPrivateTemplateRecord(CloneVMCmd cmd, Account templateOwner, VolumeApiService serviceObj) throws ResourceAllocationException;
+
+    VirtualMachineTemplate createPrivateTemplate(CloneVMCmd cmd) throws CloudRuntimeException;
+
    VirtualMachineTemplate createPrivateTemplateRecord(CreateTemplateCmd cmd, Account templateOwner) throws ResourceAllocationException;

    VirtualMachineTemplate createPrivateTemplate(CreateTemplateCmd command) throws CloudRuntimeException;

diff --git a/api/src/main/java/com/cloud/vm/UserVmService.java b/api/src/main/java/com/cloud/vm/UserVmService.java
@@ -18,11 +18,15 @@

 import java.util.List;
 import java.util.Map;
+import java.util.Optional;

+import com.cloud.storage.VolumeApiService;
+import com.cloud.storage.snapshot.SnapshotApiService;
 import org.apache.cloudstack.api.BaseCmd.HTTPMethod;
 import org.apache.cloudstack.api.command.admin.vm.AssignVMCmd;
 import org.apache.cloudstack.api.command.admin.vm.RecoverVMCmd;
 import org.apache.cloudstack.api.command.user.vm.AddNicToVMCmd;
+import org.apache.cloudstack.api.command.user.vm.CloneVMCmd;
 import org.apache.cloudstack.api.command.user.vm.DeployVMCmd;
 import org.apache.cloudstack.api.command.user.vm.DestroyVMCmd;
 import org.apache.cloudstack.api.command.user.vm.RebootVMCmd;
@@ -85,6 +89,17 @@ public interface UserVmService {
     */
    UserVm destroyVm(long vmId, boolean expunge) throws ResourceUnavailableException, ConcurrentOperationException;

+    /**
+     * Clone a specific VM (full clone)
+     *
+     * @param cmd
+     *           - the command specifying vmId to be cloned
+     * @return the VM if cloneVM operation is successful
+     * */
+    Optional<UserVm> cloneVirtualMachine(CloneVMCmd cmd, VolumeApiService volumeService, SnapshotApiService snapshotService) throws ResourceUnavailableException, ConcurrentOperationException, InsufficientCapacityException, ResourceAllocationException;
+
+    void checkCloneCondition(CloneVMCmd cmd) throws ResourceUnavailableException, ConcurrentOperationException, ResourceAllocationException;
+
    /**
     * Resets the password of a virtual machine.
     *
@@ -429,6 +444,9 @@ UserVm createAdvancedVirtualMachine(DataCenter zone, ServiceOffering serviceOffe
    UserVm createVirtualMachine(DeployVMCmd cmd) throws InsufficientCapacityException, ResourceUnavailableException, ConcurrentOperationException,
        StorageUnavailableException, ResourceAllocationException;

+    UserVm recordVirtualMachineToDB(CloneVMCmd cmd) throws InsufficientCapacityException, ResourceUnavailableException, ConcurrentOperationException,
+            StorageUnavailableException, ResourceAllocationException;
+
    UserVm getUserVm(long vmId);

    /**

diff --git a/api/src/main/java/org/apache/cloudstack/api/BaseAsyncCreateCmd.java b/api/src/main/java/org/apache/cloudstack/api/BaseAsyncCreateCmd.java
@@ -48,5 +48,4 @@ public String getCreateEventType() {
    public String getCreateEventDescription() {
        return null;
    }
-
 }
diff --git a/api/src/main/java/org/apache/cloudstack/api/command/user/vm/CloneVMCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/user/vm/CloneVMCmd.java
@@ -0,0 +1,188 @@
+package org.apache.cloudstack.api.command.user.vm;
+
+import com.cloud.event.EventTypes;
+import com.cloud.exception.ConcurrentOperationException;
+import com.cloud.exception.InsufficientCapacityException;
+import com.cloud.exception.InvalidParameterValueException;
+import com.cloud.exception.ResourceAllocationException;
+import com.cloud.exception.ResourceUnavailableException;
+import com.cloud.template.VirtualMachineTemplate;
+import com.cloud.user.Account;
+import com.cloud.uservm.UserVm;
+import com.cloud.vm.VirtualMachine;
+import org.apache.cloudstack.acl.SecurityChecker.AccessType;
+import org.apache.cloudstack.api.ACL;
+import org.apache.cloudstack.api.APICommand;
+import org.apache.cloudstack.api.ApiCommandJobType;
+import org.apache.cloudstack.api.ApiConstants;
+import org.apache.cloudstack.api.ApiErrorCode;
+import org.apache.cloudstack.api.BaseAsyncCreateCustomIdCmd;
+import org.apache.cloudstack.api.Parameter;
+import org.apache.cloudstack.api.ResponseObject;
+import org.apache.cloudstack.api.ServerApiException;
+import org.apache.cloudstack.api.command.user.UserCmd;
+import org.apache.cloudstack.api.response.DomainResponse;
+import org.apache.cloudstack.api.response.UserVmResponse;
+//import org.apache.cloudstack.context.CallContext;
+import org.apache.cloudstack.context.CallContext;
+import org.apache.log4j.Logger;
+
+import java.util.Optional;
+
+@APICommand(name = "cloneVirtualMachine", responseObject = UserVmResponse.class, description = "clone a virtual VM in full clone mode",
+        responseView = ResponseObject.ResponseView.Restricted, requestHasSensitiveInfo = false, responseHasSensitiveInfo = true, entityType = {VirtualMachine.class})
+public class CloneVMCmd extends BaseAsyncCreateCustomIdCmd implements UserCmd {
+    public static final Logger s_logger = Logger.getLogger(CloneVMCmd.class.getName());
+    private static final String s_name = "clonevirtualmachineresponse";
+
+    /////////////////////////////////////////////////////
+    //////////////// API parameters /////////////////////
+    /////////////////////////////////////////////////////
+    @ACL(accessType = AccessType.OperateEntry)
+    @Parameter(name = ApiConstants.VIRTUAL_MACHINE_ID, type = CommandType.UUID, entityType=UserVmResponse.class,
+            required = true, description = "The ID of the virtual machine")
+    private Long id;
+
+    //Owner information
+    @Parameter(name = ApiConstants.ACCOUNT, type = CommandType.STRING, description = "an optional account for the virtual machine. Must be used with domainId.")
+    private String accountName;
+
+    @Parameter(name = ApiConstants.DOMAIN_ID, type = CommandType.UUID, entityType = DomainResponse.class, description = "an optional domainId for the virtual machine. If the account parameter is used, domainId must also be used.")
+    private Long domainId;
+
+    private Long temporaryTemlateId;
+
+    private Long temporarySnapShotId;
+
+    public String getAccountName() {
+        return accountName;
+    }
+
+    public Long getDomainId() {
+        return domainId;
+    }
+
+    public Long getId() {
+        return this.id;
+    }
+    @Override
+    public String getEventType() {
+        return EventTypes.EVENT_VM_CLONE;
+    }
+
+    @Override
+    public ApiCommandJobType getInstanceType() {
+        return ApiCommandJobType.VirtualMachine;
+    }
+
+    @Override
+    public String getEventDescription() {
+        return "Cloning user VM: " + this._uuidMgr.getUuid(VirtualMachine.class, getId());
+    }
+
+    public Long getTemporaryTemlateId() {
+        return this.temporaryTemlateId;
+    }
+
+    public void setTemporarySnapShotId(Long snapshotId) {
+        this.temporarySnapShotId = snapshotId;
+    }
+
+    public Long getTemporarySnapShotId() {
+        return temporarySnapShotId;
+    }
+
+
+    public void setTemporaryTemlateId(long tempId) {
+        this.temporaryTemlateId = tempId;
+    }
+
+    @Override
+    public void create() throws ResourceAllocationException {
+        try {
+            _userVmService.checkCloneCondition(this);
+            VirtualMachineTemplate template = _templateService.createPrivateTemplateRecord(this, _accountService.getAccount(getEntityOwnerId()), _volumeService);
+            if (template == null) {
+                throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "failed to create a template to db");
+            }
+            s_logger.info("The template id recorded is: " + template.getId());
+            setTemporaryTemlateId(template.getId());
+            _templateService.createPrivateTemplate(this);
+            _snapshotService.deleteSnapshot(getTemporarySnapShotId());
+            UserVm vmRecord = _userVmService.recordVirtualMachineToDB(this);
+            if (vmRecord == null) {
+                throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "unable to record a new VM to db!");
+            }
+            setEntityId(vmRecord.getId());
+            setEntityUuid(vmRecord.getUuid());
+        } catch (ResourceUnavailableException | InsufficientCapacityException e) {
+            s_logger.warn("Exception: ", e);
+            throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, e.getMessage());
+        } catch (InvalidParameterValueException e) {
+            s_logger.warn("Exception: ", e);
+            throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, e.getMessage());
+        } finally {
+            if (getTemporaryTemlateId() != null) {
+                // TODO: delete template in the service
+                s_logger.warn("clearing the temporary template: " + getTemporaryTemlateId());
+            }
+        }
+    }
+
+    public boolean isPublic() {
+        return false;
+    }
+
+    public String getVMName() {
+        return getTargetVM().getInstanceName();
+    }
+
+    public String getTemplateName() {
+        return getVMName() + "-QA";
+    }
+
+    @Override
+    public void execute() {
+        Optional<UserVm> result;
+        try {
+            CallContext.current().setEventDetails("Vm Id for full clone: " + getEntityId());
+            s_logger.info("starting actual VM id: " + getEntityId());
+            result = _userVmService.cloneVirtualMachine(this, _volumeService, _snapshotService);
+        } catch (ResourceUnavailableException ex) {
+            s_logger.warn("Exception: ", ex);
+            throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, ex.getMessage());
+        } catch (ConcurrentOperationException ex) {
+            s_logger.warn("Exception: ", ex);
+            throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, ex.getMessage());
+        }
+        catch (ResourceAllocationException | InsufficientCapacityException ex) {
+            s_logger.warn("Exception: ", ex);
+            throw new ServerApiException(ApiErrorCode.RESOURCE_ALLOCATION_ERROR, ex.getMessage());
+        }
+        result.ifPresentOrElse((userVm)-> {
+            UserVmResponse response = _responseGenerator.createUserVmResponse(getResponseView(), "virtualmachine", result.get()).get(0);
+            response.setResponseName("full_clone");
+            setResponseObject(response);
+        }, ()-> {
+            throw new ServerApiException(ApiErrorCode.INSUFFICIENT_CAPACITY_ERROR, "failed to clone VM: " + getId());
+        });
+    }
+
+    @Override
+    public String getCommandName() {
+        return s_name;
+    }
+
+    @Override
+    public long getEntityOwnerId() {
+        UserVm vm = this._responseGenerator.findUserVmById(getId());
+        if (vm != null) {
+            return vm.getAccountId();
+        }
+        return Account.ACCOUNT_ID_SYSTEM;
+    }
+
+    public UserVm getTargetVM() {
+        return this._userVmService.getUserVm(getId());
+    }
+}
diff --git a/server/src/main/java/com/cloud/network/NetworkModelImpl.java b/server/src/main/java/com/cloud/network/NetworkModelImpl.java
@@ -30,6 +30,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.stream.Collectors;

 import javax.inject.Inject;
 import javax.naming.ConfigurationException;
@@ -831,6 +832,15 @@ public List<NetworkVO> listNetworksUsedByVm(long vmId, boolean isSystem) {
        return networks;
    }

+    @Override
+    public List<Long> listNetworksUsedByVm(long vmId) {
+        return listNetworksUsedByVm(vmId, false).
+                stream().
+                mapToLong(NetworkVO::getId).
+                boxed().
+                collect(Collectors.toList());
+    }
+
    @Override
    public Nic getNicInNetwork(long vmId, long networkId) {
        return _nicDao.findByNtwkIdAndInstanceId(networkId, vmId);

diff --git a/server/src/main/java/com/cloud/server/ManagementServerImpl.java b/server/src/main/java/com/cloud/server/ManagementServerImpl.java
@@ -468,6 +468,7 @@
 import org.apache.cloudstack.api.command.user.template.UpdateTemplatePermissionsCmd;
 import org.apache.cloudstack.api.command.user.vm.AddIpToVmNicCmd;
 import org.apache.cloudstack.api.command.user.vm.AddNicToVMCmd;
+import org.apache.cloudstack.api.command.user.vm.CloneVMCmd;
 import org.apache.cloudstack.api.command.user.vm.DeployVMCmd;
 import org.apache.cloudstack.api.command.user.vm.DestroyVMCmd;
 import org.apache.cloudstack.api.command.user.vm.GetVMPasswordCmd;
@@ -3236,6 +3237,7 @@ public List<Class<?>> getCommands() {
        cmdList.add(ExpungeVMCmd.class);
        cmdList.add(GetVMPasswordCmd.class);
        cmdList.add(ListVMsCmd.class);
+        cmdList.add(CloneVMCmd.class);
        cmdList.add(ScaleVMCmd.class);
        cmdList.add(RebootVMCmd.class);
        cmdList.add(RemoveNicFromVMCmd.class);

diff --git a/server/src/main/java/com/cloud/storage/VolumeApiServiceImpl.java b/server/src/main/java/com/cloud/storage/VolumeApiServiceImpl.java
@@ -33,6 +33,7 @@

 import javax.inject.Inject;

+import org.apache.cloudstack.api.command.user.vm.CloneVMCmd;
 import com.cloud.api.query.dao.ServiceOfferingJoinDao;
 import com.cloud.api.query.vo.ServiceOfferingJoinVO;
 import org.apache.cloudstack.api.command.user.volume.AttachVolumeCmd;
@@ -908,6 +909,12 @@ public VolumeVO createVolume(CreateVolumeCmd cmd) {
        }
    }

+    @Override
+    public Volume cloneDataVolume(CloneVMCmd cmd, long snapshotId, Volume volume) throws StorageUnavailableException {
+        long vmId = cmd.getEntityId();
+        return createVolumeFromSnapshot((VolumeVO) volume, snapshotId, vmId);
+    }
+
    protected VolumeVO createVolumeFromSnapshot(VolumeVO volume, long snapshotId, Long vmId) throws StorageUnavailableException {
        VolumeInfo createdVolume = null;
        SnapshotVO snapshot = _snapshotDao.findById(snapshotId);
@@ -1698,6 +1705,11 @@ private Volume orchestrateAttachVolumeToVM(Long vmId, Long volumeId, Long device
        return newVol;
    }

+    @Override
+    public Volume attachVolumeToVm(CloneVMCmd cmd, Long volumeId, Long deviceId) {
+        return attachVolumeToVM(cmd.getEntityId(), volumeId, deviceId);
+    }
+
    public Volume attachVolumeToVM(Long vmId, Long volumeId, Long deviceId) {
        Account caller = CallContext.current().getCallingAccount();