Clone a Virtual Machine

api/src/main/java/com/cloud/event/EventTypes.java

@@ -110,6 +110,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";

api/src/main/java/com/cloud/network/NetworkModel.java

@@ -122,6 +122,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);

api/src/main/java/com/cloud/storage/Snapshot.java

@@ -26,7 +26,8 @@
 
 public interface Snapshot extends ControlledEntity, Identity, InternalIdentity, StateObject<Snapshot.State> {
     public enum Type {
-        MANUAL, RECURRING, TEMPLATE, HOURLY, DAILY, WEEKLY, MONTHLY, GROUP;
+        MANUAL, RECURRING, TEMPLATE, HOURLY, DAILY, WEEKLY, MONTHLY, GROUP, INTERNAL;
+        // New types should be defined after INTERNAL, and change the max value
         private int max = 8;
 
         public void setMax(int max) {
@@ -71,6 +72,7 @@ enum LocationType {
     }
 
     public static final long MANUAL_POLICY_ID = 0L;
+    public static final long INTERNAL_POLICY_ID = 8L;
 
     @Override
     long getAccountId();

api/src/main/java/com/cloud/storage/VolumeApiService.java

@@ -21,6 +21,7 @@
 import java.net.MalformedURLException;
 import java.util.Map;
 
+import com.cloud.exception.StorageUnavailableException;
 import org.apache.cloudstack.api.command.user.volume.AttachVolumeCmd;
 import org.apache.cloudstack.api.command.user.volume.ChangeOfferingForVolumeCmd;
 import org.apache.cloudstack.api.command.user.volume.CreateVolumeCmd;
@@ -101,6 +102,8 @@ public interface VolumeApiService {
 
     Volume detachVolumeViaDestroyVM(long vmId, long volumeId);
 
+    Volume cloneDataVolume(long vmId, 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)
@@ -110,6 +113,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, String name);
 
+    Volume attachVolumeToVM(Long vmId, Long volumeId, Long deviceId);
+
     /**
      * Extracts the volume to a particular location.
      *

api/src/main/java/com/cloud/template/TemplateApiService.java

@@ -20,6 +20,9 @@
 import java.net.URISyntaxException;
 import java.util.List;
 
+import com.cloud.storage.Snapshot;
+import com.cloud.storage.VolumeApiService;
+import com.cloud.uservm.UserVm;
 import org.apache.cloudstack.api.BaseListTemplateOrIsoPermissionsCmd;
 import org.apache.cloudstack.api.BaseUpdateTemplateOrIsoPermissionsCmd;
 import org.apache.cloudstack.api.command.user.iso.DeleteIsoCmd;
@@ -40,6 +43,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.command.user.userdata.LinkUserDataToTemplateCmd;
 import org.apache.cloudstack.api.response.GetUploadParamsResponse;
 
@@ -102,6 +106,15 @@ public interface TemplateApiService {
 
     boolean updateTemplateOrIsoPermissions(BaseUpdateTemplateOrIsoPermissionsCmd cmd);
 
+    Snapshot createSnapshotFromTemplateOwner(long vmId, UserVm curVm, Account templateOwner, VolumeApiService volumeService) throws ResourceAllocationException;
+
+    /**
+     * create a template record for later usage of creating a real template by createPrivateTemplate
+     * */
+    VirtualMachineTemplate createPrivateTemplateRecord(CloneVMCmd cmd, Account templateOwner, VolumeApiService serviceObj, Snapshot snapshot) throws ResourceAllocationException;
+
+    VirtualMachineTemplate createPrivateTemplate(CloneVMCmd cmd, long snapshotId, long templateId) throws CloudRuntimeException;
+
     VirtualMachineTemplate createPrivateTemplateRecord(CreateTemplateCmd cmd, Account templateOwner) throws ResourceAllocationException;
 
     VirtualMachineTemplate createPrivateTemplate(CreateTemplateCmd command) throws CloudRuntimeException;

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;
@@ -86,6 +90,18 @@ 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 validateCloneCondition(CloneVMCmd cmd) throws ResourceUnavailableException, ConcurrentOperationException, ResourceAllocationException;
+
+    void prepareCloneVirtualMachine(CloneVMCmd cmd) throws ResourceAllocationException, InsufficientCapacityException, ResourceUnavailableException;
     /**
      * Resets the password of a virtual machine.
      *
@@ -432,6 +448,9 @@ UserVm createAdvancedVirtualMachine(DataCenter zone, ServiceOffering serviceOffe
     UserVm createVirtualMachine(DeployVMCmd cmd) throws InsufficientCapacityException, ResourceUnavailableException, ConcurrentOperationException,
         StorageUnavailableException, ResourceAllocationException;
 
+    UserVm recordVirtualMachineToDB(CloneVMCmd cmd, long templateId) throws InsufficientCapacityException, ResourceUnavailableException, ConcurrentOperationException,
+            StorageUnavailableException, ResourceAllocationException;
+
     UserVm getUserVm(long vmId);
 
     VirtualMachine getVm(long vmId);

api/src/main/java/org/apache/cloudstack/api/BaseAsyncCreateCmd.java

@@ -48,5 +48,4 @@ public String getCreateEventType() {
     public String getCreateEventDescription() {
         return null;
     }
-
 }

api/src/main/java/org/apache/cloudstack/api/command/user/vm/CloneVMCmd.java

@@ -0,0 +1,185 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+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.utils.exception.CloudRuntimeException;
+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.BaseAsyncCreateCmd;
+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.log4j.Logger;
+
+import java.util.Optional;
+
+@APICommand(name = "cloneVirtualMachine", responseObject = UserVmResponse.class, description = "clone a virtual VM",
+        responseView = ResponseObject.ResponseView.Restricted, requestHasSensitiveInfo = false, responseHasSensitiveInfo = true, entityType = {VirtualMachine.class}, since="4.16.0")
+public class CloneVMCmd extends BaseAsyncCreateCmd implements UserCmd {
+    public static final Logger s_logger = Logger.getLogger(CloneVMCmd.class.getName());
+    private static final String s_name = "clonevirtualmachineresponse";
+    private static final String CLONE_IDENTIFIER = "Clone";
+
+    /////////////////////////////////////////////////////
+    //////////////// 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 virtualmachineid;
+
+    @Parameter(name = ApiConstants.NAME, type = CommandType.STRING, description = "name of the cloned virtual machine")
+    private String name;
+
+    //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;
+
+    public String getAccountName() {
+        return accountName;
+    }
+
+    public Long getDomainId() {
+        return domainId;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return this.virtualmachineid;
+    }
+    @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());
+    }
+
+    @Override
+    public void create() throws ResourceAllocationException {
+        try {
+            _userVmService.validateCloneCondition(this);
+            _userVmService.prepareCloneVirtualMachine(this);
+        }
+        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());
+        } catch (ServerApiException e) {
+            throw new ServerApiException(e.getErrorCode(), e.getDescription());
+        } catch (CloudRuntimeException e) {
+            throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, e.getMessage());
+        }
+    }
+
+    public boolean isPublic() {
+        return false;
+    }
+
+    public String getVMName() {
+        if (getName() == null) {
+            return getTargetVM().getInstanceName() + "-" + CLONE_IDENTIFIER;
+        }
+        return getName();
+    }
+
+    public String getTemplateName() {
+        return (getVMName() + "-" + _uuidMgr.generateUuid(VirtualMachineTemplate.class, null)).substring(0, 32);
+    }
+
+    @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());
+    }
+}

engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/snapshot/SnapshotServiceImpl.java

@@ -221,8 +221,11 @@ public SnapshotResult takeSnapshot(SnapshotInfo snap) {
 
         try {
             result = future.get();
-            UsageEventUtils.publishUsageEvent(EventTypes.EVENT_SNAPSHOT_ON_PRIMARY, snap.getAccountId(), snap.getDataCenterId(), snap.getId(),
-                    snap.getName(), null, null, snapshotOnPrimary.getSize(), snapshotOnPrimary.getSize(), snap.getClass().getName(), snap.getUuid());
+            SnapshotVO snapVO = _snapshotDao.findById(snap.getId());
+            if (snapVO == null || snapVO.getSnapshotType() != Snapshot.Type.INTERNAL.ordinal()) {
+                UsageEventUtils.publishUsageEvent(EventTypes.EVENT_SNAPSHOT_ON_PRIMARY, snap.getAccountId(), snap.getDataCenterId(), snap.getId(),
+                        snap.getName(), null, null, snapshotOnPrimary.getSize(), snapshotOnPrimary.getSize(), snap.getClass().getName(), snap.getUuid());
+            }
             return result;
         } catch (InterruptedException e) {
             s_logger.debug("Failed to create snapshot", e);

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;
@@ -845,6 +846,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);

server/src/main/java/com/cloud/server/ManagementServerImpl.java

@@ -521,6 +521,7 @@
 import org.apache.cloudstack.api.command.user.userdata.RegisterUserDataCmd;
 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;
@@ -3486,6 +3487,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);