// 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 com.cloud.vm;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.UUID;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.TimeUnit;

import javax.ejb.Local;

import javax.inject.Inject;

import javax.naming.ConfigurationException;

import com.cloud.event.ActionEvent;

import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreDao;

import org.apache.cloudstack.storage.datastore.db.TemplateDataStoreVO;

import org.apache.commons.codec.binary.Base64;

import org.apache.log4j.Logger;

import org.apache.cloudstack.acl.ControlledEntity.ACLType;

import org.apache.cloudstack.acl.SecurityChecker.AccessType;

import org.apache.cloudstack.affinity.AffinityGroupService;

import org.apache.cloudstack.affinity.AffinityGroupVO;

import org.apache.cloudstack.affinity.dao.AffinityGroupDao;

import org.apache.cloudstack.affinity.dao.AffinityGroupVMMapDao;

import org.apache.cloudstack.api.ApiConstants;

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.DeployVMCmd;

import org.apache.cloudstack.api.command.user.vm.DestroyVMCmd;

import org.apache.cloudstack.api.command.user.vm.RebootVMCmd;

import org.apache.cloudstack.api.command.user.vm.RemoveNicFromVMCmd;

import org.apache.cloudstack.api.command.user.vm.ResetVMPasswordCmd;

import org.apache.cloudstack.api.command.user.vm.ResetVMSSHKeyCmd;

import org.apache.cloudstack.api.command.user.vm.RestoreVMCmd;

import org.apache.cloudstack.api.command.user.vm.ScaleVMCmd;

import org.apache.cloudstack.api.command.user.vm.StartVMCmd;

import org.apache.cloudstack.api.command.user.vm.UpdateDefaultNicForVMCmd;

import org.apache.cloudstack.api.command.user.vm.UpdateVMCmd;

import org.apache.cloudstack.api.command.user.vm.UpgradeVMCmd;

import org.apache.cloudstack.api.command.user.vmgroup.CreateVMGroupCmd;

import org.apache.cloudstack.api.command.user.vmgroup.DeleteVMGroupCmd;

import org.apache.cloudstack.context.CallContext;

import org.apache.cloudstack.engine.cloud.entity.api.VirtualMachineEntity;

import org.apache.cloudstack.engine.cloud.entity.api.db.dao.VMNetworkMapDao;

import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;

import org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService;

import org.apache.cloudstack.engine.service.api.OrchestrationService;

import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;

import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;

import org.apache.cloudstack.engine.subsystem.api.storage.PrimaryDataStore;

import org.apache.cloudstack.engine.subsystem.api.storage.TemplateDataFactory;

import org.apache.cloudstack.engine.subsystem.api.storage.VolumeDataFactory;

import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;

import org.apache.cloudstack.engine.subsystem.api.storage.VolumeService;

import org.apache.cloudstack.engine.subsystem.api.storage.VolumeService.VolumeApiResult;

import org.apache.cloudstack.framework.async.AsyncCallFuture;

import org.apache.cloudstack.framework.config.ConfigKey;

import org.apache.cloudstack.framework.config.Configurable;

import org.apache.cloudstack.framework.config.dao.ConfigurationDao;

import org.apache.cloudstack.framework.jobs.AsyncJobManager;

import org.apache.cloudstack.managed.context.ManagedContextRunnable;

import org.apache.cloudstack.storage.command.DeleteCommand;

import org.apache.cloudstack.storage.command.DettachCommand;

import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;

import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;

import com.cloud.agent.AgentManager;

import com.cloud.agent.api.Answer;

import com.cloud.agent.api.Command;

import com.cloud.agent.api.GetVmDiskStatsAnswer;

import com.cloud.agent.api.GetVmDiskStatsCommand;

import com.cloud.agent.api.GetVmStatsAnswer;

import com.cloud.agent.api.GetVmStatsCommand;

import com.cloud.agent.api.PvlanSetupCommand;

import com.cloud.agent.api.GetVmIpAddressCommand;

import com.cloud.agent.api.StartAnswer;

import com.cloud.agent.api.VmDiskStatsEntry;

import com.cloud.agent.api.VmStatsEntry;

import com.cloud.agent.api.to.DiskTO;

import com.cloud.agent.api.to.NicTO;

import com.cloud.agent.api.to.VirtualMachineTO;

import com.cloud.agent.manager.Commands;

import com.cloud.alert.AlertManager;

import com.cloud.api.ApiDBUtils;

import com.cloud.api.query.dao.UserVmJoinDao;

import com.cloud.capacity.Capacity;

import com.cloud.capacity.CapacityManager;

import com.cloud.configuration.Config;

import com.cloud.configuration.ConfigurationManager;

import com.cloud.configuration.Resource.ResourceType;

import com.cloud.dc.DataCenter;

import com.cloud.dc.DataCenter.NetworkType;

import com.cloud.dc.DataCenterVO;

import com.cloud.dc.DedicatedResourceVO;

import com.cloud.dc.HostPodVO;

import com.cloud.dc.dao.ClusterDao;

import com.cloud.dc.dao.DataCenterDao;

import com.cloud.dc.dao.DedicatedResourceDao;

import com.cloud.dc.dao.HostPodDao;

import com.cloud.deploy.DataCenterDeployment;

import com.cloud.deploy.DeployDestination;

import com.cloud.deploy.DeploymentPlanner;

import com.cloud.deploy.DeploymentPlanner.ExcludeList;

import com.cloud.deploy.DeploymentPlanningManager;

import com.cloud.deploy.PlannerHostReservationVO;

import com.cloud.deploy.dao.PlannerHostReservationDao;

import com.cloud.domain.DomainVO;

import com.cloud.domain.Domain;

import com.cloud.domain.dao.DomainDao;

import com.cloud.event.EventTypes;

import com.cloud.event.ActionEventUtils;

import com.cloud.event.UsageEventUtils;

import com.cloud.event.UsageEventVO;

import com.cloud.event.dao.UsageEventDao;

import com.cloud.exception.AgentUnavailableException;

import com.cloud.exception.CloudException;

import com.cloud.exception.ConcurrentOperationException;

import com.cloud.exception.InsufficientCapacityException;

import com.cloud.exception.InvalidParameterValueException;

import com.cloud.exception.ManagementServerException;

import com.cloud.exception.OperationTimedoutException;

import com.cloud.exception.PermissionDeniedException;

import com.cloud.exception.ResourceAllocationException;

import com.cloud.exception.ResourceUnavailableException;

import com.cloud.exception.StorageUnavailableException;

import com.cloud.exception.VirtualMachineMigrationException;

import com.cloud.gpu.GPU;

import com.cloud.ha.HighAvailabilityManager;

import com.cloud.host.Host;

import com.cloud.host.HostVO;

import com.cloud.host.dao.HostDao;

import com.cloud.hypervisor.Hypervisor.HypervisorType;

import com.cloud.hypervisor.HypervisorCapabilitiesVO;

import com.cloud.hypervisor.dao.HypervisorCapabilitiesDao;

import com.cloud.network.Network;

import com.cloud.network.Network.IpAddresses;

import com.cloud.network.Network.Provider;

import com.cloud.network.Network.Service;

import com.cloud.network.NetworkModel;

import com.cloud.network.Networks.TrafficType;

import com.cloud.network.PhysicalNetwork;

import com.cloud.network.dao.FirewallRulesDao;

import com.cloud.network.dao.IPAddressDao;

import com.cloud.network.dao.IPAddressVO;

import com.cloud.network.dao.LoadBalancerVMMapDao;

import com.cloud.network.dao.LoadBalancerVMMapVO;

import com.cloud.network.dao.NetworkDao;

import com.cloud.network.dao.NetworkServiceMapDao;

import com.cloud.network.dao.NetworkVO;

import com.cloud.network.dao.PhysicalNetworkDao;

import com.cloud.network.element.UserDataServiceProvider;

import com.cloud.network.guru.NetworkGuru;

import com.cloud.network.lb.LoadBalancingRulesManager;

import com.cloud.network.router.VpcVirtualNetworkApplianceManager;

import com.cloud.network.rules.FirewallManager;

import com.cloud.network.rules.FirewallRuleVO;

import com.cloud.network.rules.PortForwardingRuleVO;

import com.cloud.network.rules.RulesManager;

import com.cloud.network.rules.dao.PortForwardingRulesDao;

import com.cloud.network.security.SecurityGroup;

import com.cloud.network.security.SecurityGroupManager;

import com.cloud.network.security.dao.SecurityGroupDao;

import com.cloud.network.security.dao.SecurityGroupVMMapDao;

import com.cloud.network.vpc.VpcManager;

import com.cloud.network.vpc.dao.VpcDao;

import com.cloud.offering.NetworkOffering;

import com.cloud.offering.NetworkOffering.Availability;

import com.cloud.offering.ServiceOffering;

import com.cloud.offerings.NetworkOfferingVO;

import com.cloud.offerings.dao.NetworkOfferingDao;

import com.cloud.org.Cluster;

import com.cloud.org.Grouping;

import com.cloud.projects.ProjectManager;

import com.cloud.resource.ResourceManager;

import com.cloud.resource.ResourceState;

import com.cloud.server.ConfigurationServer;

import com.cloud.server.ManagementService;

import com.cloud.service.ServiceOfferingVO;

import com.cloud.service.dao.ServiceOfferingDao;

import com.cloud.service.dao.ServiceOfferingDetailsDao;

import com.cloud.storage.DataStoreRole;

import com.cloud.storage.DiskOfferingVO;

import com.cloud.storage.GuestOSCategoryVO;

import com.cloud.storage.GuestOSVO;

import com.cloud.storage.SnapshotVO;

import com.cloud.storage.Storage;

import com.cloud.storage.Storage.ImageFormat;

import com.cloud.storage.Storage.TemplateType;

import com.cloud.storage.StorageManager;

import com.cloud.storage.StoragePool;

import com.cloud.storage.StoragePoolStatus;

import com.cloud.storage.VMTemplateVO;

import com.cloud.storage.VMTemplateZoneVO;

import com.cloud.storage.Volume;

import com.cloud.storage.VolumeApiService;

import com.cloud.storage.VolumeVO;

import com.cloud.storage.dao.DiskOfferingDao;

import com.cloud.storage.dao.GuestOSCategoryDao;

import com.cloud.storage.dao.GuestOSDao;

import com.cloud.storage.dao.SnapshotDao;

import com.cloud.storage.dao.VMTemplateDao;

import com.cloud.storage.dao.VMTemplateDetailsDao;

import com.cloud.storage.dao.VMTemplateZoneDao;

import com.cloud.storage.dao.VolumeDao;

import com.cloud.storage.snapshot.SnapshotManager;

import com.cloud.tags.dao.ResourceTagDao;

import com.cloud.template.TemplateManager;

import com.cloud.template.VirtualMachineTemplate;

import com.cloud.user.Account;

import com.cloud.user.AccountManager;

import com.cloud.user.AccountService;

import com.cloud.user.ResourceLimitService;

import com.cloud.user.SSHKeyPair;

import com.cloud.user.SSHKeyPairVO;

import com.cloud.user.User;

import com.cloud.user.UserVO;

import com.cloud.user.VmDiskStatisticsVO;

import com.cloud.user.dao.AccountDao;

import com.cloud.user.dao.SSHKeyPairDao;

import com.cloud.user.dao.UserDao;

import com.cloud.user.dao.VmDiskStatisticsDao;

import com.cloud.uservm.UserVm;

import com.cloud.utils.DateUtil;

import com.cloud.utils.Journal;

import com.cloud.utils.NumbersUtil;

import com.cloud.utils.Pair;

import com.cloud.utils.component.ManagerBase;

import com.cloud.utils.concurrency.NamedThreadFactory;

import com.cloud.utils.crypt.DBEncryptionUtil;

import com.cloud.utils.crypt.RSAHelper;

import com.cloud.utils.db.DB;

import com.cloud.utils.db.EntityManager;

import com.cloud.utils.db.GlobalLock;

import com.cloud.utils.db.SearchCriteria;

import com.cloud.utils.db.Transaction;

import com.cloud.utils.db.TransactionCallbackNoReturn;

import com.cloud.utils.db.TransactionCallbackWithException;

import com.cloud.utils.db.TransactionCallbackWithExceptionNoReturn;

import com.cloud.utils.db.TransactionStatus;

import com.cloud.utils.db.UUIDManager;

import com.cloud.utils.exception.CloudRuntimeException;

import com.cloud.utils.exception.ExecutionException;

import com.cloud.utils.fsm.NoTransitionException;

import com.cloud.utils.net.NetUtils;

import com.cloud.vm.VirtualMachine.State;

import com.cloud.vm.dao.DomainRouterDao;

import com.cloud.vm.dao.InstanceGroupDao;

import com.cloud.vm.dao.InstanceGroupVMMapDao;

import com.cloud.vm.dao.NicDao;

import com.cloud.vm.dao.SecondaryStorageVmDao;

import com.cloud.vm.dao.UserVmCloneSettingDao;

import com.cloud.vm.dao.UserVmDao;

import com.cloud.vm.dao.UserVmDetailsDao;

import com.cloud.vm.dao.VMInstanceDao;

import com.cloud.vm.snapshot.VMSnapshotManager;

import com.cloud.vm.snapshot.VMSnapshotVO;

import com.cloud.vm.snapshot.dao.VMSnapshotDao;

@Local(value = {UserVmManager.class, UserVmService.class})

public class UserVmManagerImpl extends ManagerBase implements UserVmManager, VirtualMachineGuru, UserVmService, Configurable {

private static final Logger s_logger = Logger.getLogger(UserVmManagerImpl.class);

private static final int ACQUIRE_GLOBAL_LOCK_TIMEOUT_FOR_COOPERATION = 3; // 3

// seconds

public enum UserVmCloneType {

full, linked

}

@Inject

EntityManager _entityMgr;

@Inject

protected HostDao _hostDao = null;

@Inject

protected ServiceOfferingDao _offeringDao = null;

@Inject

protected DiskOfferingDao _diskOfferingDao = null;

@Inject

protected VMTemplateDao _templateDao = null;

@Inject

protected VMTemplateDetailsDao _templateDetailsDao = null;

@Inject

protected VMTemplateZoneDao _templateZoneDao = null;

@Inject

protected TemplateDataStoreDao _templateStoreDao;

@Inject

protected DomainDao _domainDao = null;

@Inject

protected UserVmCloneSettingDao _vmCloneSettingDao = null;

@Inject

protected UserVmDao _vmDao = null;

@Inject

protected UserVmJoinDao _vmJoinDao = null;

@Inject

protected VolumeDao _volsDao = null;

@Inject

protected DataCenterDao _dcDao = null;

@Inject

protected FirewallRulesDao _rulesDao = null;

@Inject

protected LoadBalancerVMMapDao _loadBalancerVMMapDao = null;

@Inject

protected PortForwardingRulesDao _portForwardingDao;

@Inject

protected IPAddressDao _ipAddressDao = null;

@Inject

protected HostPodDao _podDao = null;

@Inject

protected NetworkModel _networkModel = null;

@Inject

protected NetworkOrchestrationService _networkMgr = null;

@Inject

protected StorageManager _storageMgr = null;

@Inject

protected SnapshotManager _snapshotMgr = null;

@Inject

protected AgentManager _agentMgr = null;

@Inject

protected ConfigurationManager _configMgr = null;

@Inject

protected AccountDao _accountDao = null;

@Inject

protected UserDao _userDao = null;

@Inject

protected SnapshotDao _snapshotDao = null;

@Inject

protected GuestOSDao _guestOSDao = null;

@Inject

protected HighAvailabilityManager _haMgr = null;

@Inject

protected AlertManager _alertMgr = null;

@Inject

protected AccountManager _accountMgr;

@Inject

protected AccountService _accountService;

@Inject

protected AsyncJobManager _asyncMgr;

@Inject

protected ClusterDao _clusterDao;

@Inject

protected PrimaryDataStoreDao _storagePoolDao;

@Inject

protected SecurityGroupManager _securityGroupMgr;

@Inject

protected ServiceOfferingDao _serviceOfferingDao;

@Inject

protected NetworkOfferingDao _networkOfferingDao;

@Inject

protected InstanceGroupDao _vmGroupDao;

@Inject

protected InstanceGroupVMMapDao _groupVMMapDao;

@Inject

protected VirtualMachineManager _itMgr;

@Inject

protected NetworkDao _networkDao;

@Inject

protected NicDao _nicDao;

@Inject

protected ServiceOfferingDao _offerringDao;

@Inject

protected VpcDao _vpcDao;

@Inject

protected RulesManager _rulesMgr;

@Inject

protected LoadBalancingRulesManager _lbMgr;

@Inject

protected SSHKeyPairDao _sshKeyPairDao;

@Inject

protected UserVmDetailsDao _vmDetailsDao;

@Inject

protected HypervisorCapabilitiesDao _hypervisorCapabilitiesDao;

@Inject

protected SecurityGroupDao _securityGroupDao;

@Inject

protected CapacityManager _capacityMgr;

@Inject

protected VMInstanceDao _vmInstanceDao;

@Inject

protected ResourceLimitService _resourceLimitMgr;

@Inject

protected FirewallManager _firewallMgr;

@Inject

protected ProjectManager _projectMgr;

@Inject

protected ResourceManager _resourceMgr;

@Inject

protected NetworkServiceMapDao _ntwkSrvcDao;

@Inject

SecurityGroupVMMapDao _securityGroupVMMapDao;

@Inject

protected ItWorkDao _workDao;

@Inject

ResourceTagDao _resourceTagDao;

@Inject

PhysicalNetworkDao _physicalNetworkDao;

@Inject

VpcManager _vpcMgr;

@Inject

TemplateManager _templateMgr;

@Inject

protected GuestOSCategoryDao _guestOSCategoryDao;

@Inject

UsageEventDao _usageEventDao;

@Inject

SecondaryStorageVmDao _secondaryDao;

@Inject

VmDiskStatisticsDao _vmDiskStatsDao;

@Inject

protected VMSnapshotDao _vmSnapshotDao;

@Inject

protected VMSnapshotManager _vmSnapshotMgr;

@Inject

AffinityGroupVMMapDao _affinityGroupVMMapDao;

@Inject

AffinityGroupDao _affinityGroupDao;

@Inject

TemplateDataFactory templateFactory;

@Inject

DedicatedResourceDao _dedicatedDao;

@Inject

ConfigurationServer _configServer;

@Inject

AffinityGroupService _affinityGroupService;

@Inject

PlannerHostReservationDao _plannerHostReservationDao;

@Inject

private ServiceOfferingDetailsDao serviceOfferingDetailsDao;

@Inject

VolumeService _volService;

@Inject

VolumeDataFactory volFactory;

@Inject

UserVmDetailsDao _uservmDetailsDao;

@Inject

UUIDManager _uuidMgr;

@Inject

DeploymentPlanningManager _planningMgr;

@Inject

VolumeApiService _volumeService;

@Inject

DataStoreManager _dataStoreMgr;

@Inject

VpcVirtualNetworkApplianceManager _virtualNetAppliance;

@Inject

DomainRouterDao _routerDao;

@Inject

protected VMNetworkMapDao _vmNetworkMapDao;

protected ScheduledExecutorService _executor = null;

protected int _expungeInterval;

protected int _expungeDelay;

protected boolean _dailyOrHourly = false;

private int capacityReleaseInterval;

ExecutorService _vmIpFetchThreadExecutor;

protected String _instance;

protected String _zone;

protected boolean _instanceNameFlag;

protected int _scaleRetry;

protected Map<Long, VmAndCountDetails> vmIdCountMap = new ConcurrentHashMap<>();

@Inject

ConfigurationDao _configDao;

private static final int MAX_VM_NAME_LEN = 80;

private static final int MAX_HTTP_GET_LENGTH = 2 * MAX_USER_DATA_LENGTH_BYTES;

private static final int MAX_HTTP_POST_LENGTH = 16 * MAX_USER_DATA_LENGTH_BYTES;

@Inject

protected OrchestrationService _orchSrvc;

@Inject

VolumeOrchestrationService volumeMgr;

@Inject

ManagementService _mgr;

static final ConfigKey<Integer> VmIpFetchWaitInterval = new ConfigKey<Integer>("Advanced", Integer.class, "externaldhcp.vmip.retrieval.interval", "180",

"Wait Interval (in seconds) for shared network vm dhcp ip addr fetch for next iteration ", true);

static final ConfigKey<Integer> VmIpFetchTrialMax = new ConfigKey<Integer>("Advanced", Integer.class, "externaldhcp.vmip.max.retry", "10",

"The max number of retrieval times for shared entwork vm dhcp ip fetch, in case of failures", true);

static final ConfigKey<Integer> VmIpFetchThreadPoolMax = new ConfigKey<Integer>("Advanced", Integer.class, "externaldhcp.vmipFetch.threadPool.max", "10",

"number of threads for fetching vms ip address", true);

@Override

public UserVmVO getVirtualMachine(long vmId) {

return _vmDao.findById(vmId);

}

@Override

public List<? extends UserVm> getVirtualMachines(long hostId) {

return _vmDao.listByHostId(hostId);

}

protected void resourceLimitCheck(Account owner, Boolean displayVm, Long cpu, Long memory) throws ResourceAllocationException {

_resourceLimitMgr.checkResourceLimit(owner, ResourceType.user_vm, displayVm);

_resourceLimitMgr.checkResourceLimit(owner, ResourceType.cpu, displayVm, cpu);

_resourceLimitMgr.checkResourceLimit(owner, ResourceType.memory, displayVm, memory);

}

protected void resourceCountIncrement(long accountId, Boolean displayVm, Long cpu, Long memory) {

_resourceLimitMgr.incrementResourceCount(accountId, ResourceType.user_vm, displayVm);

_resourceLimitMgr.incrementResourceCount(accountId, ResourceType.cpu, displayVm, cpu);

_resourceLimitMgr.incrementResourceCount(accountId, ResourceType.memory, displayVm, memory);

}

protected void resourceCountDecrement(long accountId, Boolean displayVm, Long cpu, Long memory) {

_resourceLimitMgr.decrementResourceCount(accountId, ResourceType.user_vm, displayVm);

_resourceLimitMgr.decrementResourceCount(accountId, ResourceType.cpu, displayVm, cpu);

_resourceLimitMgr.decrementResourceCount(accountId, ResourceType.memory, displayVm, memory);

}

public class VmAndCountDetails {

long vmId;

int retrievalCount = VmIpFetchTrialMax.value();

public VmAndCountDetails() {

}

public VmAndCountDetails (long vmId, int retrievalCount) {

this.vmId = vmId;

this.retrievalCount = retrievalCount;

}

public VmAndCountDetails (long vmId) {

this.vmId = vmId;

}

public int getRetrievalCount() {

return retrievalCount;

}

public void setRetrievalCount(int retrievalCount) {

this.retrievalCount = retrievalCount;

}

public long getVmId() {

return vmId;

}

public void setVmId(long vmId) {

this.vmId = vmId;

}

public void decrementCount() {

this.retrievalCount--;

}

}

protected class VmIpAddrFetchThread extends ManagedContextRunnable {

long nicId;

long vmId;

String vmName;

boolean isWindows;

Long hostId;

String networkCidr;

public VmIpAddrFetchThread() {

}

public VmIpAddrFetchThread(long vmId, long nicId, String instanceName, boolean windows, Long hostId, String networkCidr) {

this.vmId = vmId;

this.nicId = nicId;

this.vmName = instanceName;

this.isWindows = windows;

this.hostId = hostId;

this.networkCidr = networkCidr;

}

@Override

protected void runInContext() {

GetVmIpAddressCommand cmd = new GetVmIpAddressCommand(vmName, networkCidr, isWindows);

boolean decrementCount = true;

try {

s_logger.debug("Trying for vm "+ vmId +" nic Id "+nicId +" ip retrieval ...");

Answer answer = _agentMgr.send(hostId, cmd);

NicVO nic = _nicDao.findById(nicId);

if (answer.getResult()) {

String vmIp = answer.getDetails();

if (NetUtils.isValidIp(vmIp)) {

// set this vm ip addr in vm nic.

if (nic != null) {

nic.setIp4Address(vmIp);

_nicDao.update(nicId, nic);

s_logger.debug("Vm "+ vmId +" IP "+vmIp +" got retrieved successfully");

vmIdCountMap.remove(nicId);

decrementCount = false;

ActionEventUtils.onActionEvent(User.UID_SYSTEM, Account.ACCOUNT_ID_SYSTEM,

Domain.ROOT_DOMAIN, EventTypes.EVENT_NETWORK_EXTERNAL_DHCP_VM_IPFETCH,

"VM " + vmId + " nic id " + nicId + " ip address " + vmIp + " got fetched successfully");

}

}

} else {

//previously vm has ip and nic table has ip address. After vm restart or stop/start

//if vm doesnot get the ip then set the ip in nic table to null

if (nic.getIp4Address() != null) {

nic.setIp4Address(null);

_nicDao.update(nicId, nic);

}

if (answer.getDetails() != null) {

s_logger.debug("Failed to get vm ip for Vm "+ vmId + answer.getDetails());

}

}

} catch (OperationTimedoutException e) {

s_logger.warn("Timed Out", e);

} catch (AgentUnavailableException e) {

s_logger.warn("Agent Unavailable ", e);

} finally {

if (decrementCount) {

VmAndCountDetails vmAndCount = vmIdCountMap.get(nicId);

vmAndCount.decrementCount();

s_logger.debug("Ip is not retrieved for VM " + vmId +" nic "+nicId + " ... decremented count to "+vmAndCount.getRetrievalCount());

vmIdCountMap.put(nicId, vmAndCount);

}

}

}

}

@Override

@ActionEvent(eventType = EventTypes.EVENT_VM_RESETPASSWORD, eventDescription = "resetting Vm password", async = true)

public UserVm resetVMPassword(ResetVMPasswordCmd cmd, String password) throws ResourceUnavailableException, InsufficientCapacityException {

Account caller = CallContext.current().getCallingAccount();

Long vmId = cmd.getId();

UserVmVO userVm = _vmDao.findById(cmd.getId());

// Do parameters input validation

if (userVm == null) {

throw new InvalidParameterValueException("unable to find a virtual machine with id " + cmd.getId());

}

_vmDao.loadDetails(userVm);

VMTemplateVO template = _templateDao.findByIdIncludingRemoved(userVm.getTemplateId());

if (template == null || !template.getEnablePassword()) {

throw new InvalidParameterValueException("Fail to reset password for the virtual machine, the template is not password enabled");

}

if (userVm.getState() == State.Error || userVm.getState() == State.Expunging) {

s_logger.error("vm is not in the right state: " + vmId);

throw new InvalidParameterValueException("Vm with id " + vmId + " is not in the right state");

}

_accountMgr.checkAccess(caller, null, true, userVm);

boolean result = resetVMPasswordInternal(vmId, password);

if (result) {

userVm.setPassword(password);

// update the password in vm_details table too

// Check if an SSH key pair was selected for the instance and if so

// use it to encrypt & save the vm password

encryptAndStorePassword(userVm, password);

} else {

throw new CloudRuntimeException("Failed to reset password for the virtual machine ");

}

return userVm;

}

private boolean resetVMPasswordInternal(Long vmId, String password) throws ResourceUnavailableException, InsufficientCapacityException {

Long userId = CallContext.current().getCallingUserId();

VMInstanceVO vmInstance = _vmDao.findById(vmId);

if (password == null || password.equals("")) {

return false;

}

VMTemplateVO template = _templateDao.findByIdIncludingRemoved(vmInstance.getTemplateId());

if (template.getEnablePassword()) {

Nic defaultNic = _networkModel.getDefaultNic(vmId);

if (defaultNic == null) {

s_logger.error("Unable to reset password for vm " + vmInstance + " as the instance doesn't have default nic");

return false;

}

Network defaultNetwork = _networkDao.findById(defaultNic.getNetworkId());

NicProfile defaultNicProfile = new NicProfile(defaultNic, defaultNetwork, null, null, null, _networkModel.isSecurityGroupSupportedInNetwork(defaultNetwork),

_networkModel.getNetworkTag(template.getHypervisorType(), defaultNetwork));

VirtualMachineProfile vmProfile = new VirtualMachineProfileImpl(vmInstance);

vmProfile.setParameter(VirtualMachineProfile.Param.VmPassword, password);

UserDataServiceProvider element = _networkMgr.getPasswordResetProvider(defaultNetwork);

if (element == null) {

throw new CloudRuntimeException("Can't find network element for " + Service.UserData.getName() + " provider needed for password reset");

}

boolean result = element.savePassword(defaultNetwork, defaultNicProfile, vmProfile);

// Need to reboot the virtual machine so that the password gets

// redownloaded from the DomR, and reset on the VM

if (!result) {

s_logger.debug("Failed to reset password for the virutal machine; no need to reboot the vm");

return false;

} else {

if (vmInstance.getState() == State.Stopped) {

s_logger.debug("Vm " + vmInstance + " is stopped, not rebooting it as a part of password reset");

return true;

}

if (rebootVirtualMachine(userId, vmId) == null) {

s_logger.warn("Failed to reboot the vm " + vmInstance);

return false;

} else {

s_logger.debug("Vm " + vmInstance + " is rebooted successfully as a part of password reset");

return true;

}

}

} else {

if (s_logger.isDebugEnabled()) {

s_logger.debug("Reset password called for a vm that is not using a password enabled template");

}

return false;

}

}

@Override

@ActionEvent(eventType = EventTypes.EVENT_VM_RESETSSHKEY, eventDescription = "resetting Vm SSHKey", async = true)

public UserVm resetVMSSHKey(ResetVMSSHKeyCmd cmd) throws ResourceUnavailableException, InsufficientCapacityException {

Account caller = CallContext.current().getCallingAccount();

Account owner = _accountMgr.finalizeOwner(caller, cmd.getAccountName(), cmd.getDomainId(), cmd.getProjectId());

Long vmId = cmd.getId();

UserVmVO userVm = _vmDao.findById(cmd.getId());

if (userVm == null) {

throw new InvalidParameterValueException("unable to find a virtual machine by id" + cmd.getId());

}

_vmDao.loadDetails(userVm);

VMTemplateVO template = _templateDao.findByIdIncludingRemoved(userVm.getTemplateId());

// Do parameters input validation

if (userVm.getState() == State.Error || userVm.getState() == State.Expunging) {

s_logger.error("vm is not in the right state: " + vmId);

throw new InvalidParameterValueException("Vm with specified id is not in the right state");

}

if (userVm.getState() != State.Stopped) {

s_logger.error("vm is not in the right state: " + vmId);

throw new InvalidParameterValueException("Vm " + userVm + " should be stopped to do SSH Key reset");

}

SSHKeyPairVO s = _sshKeyPairDao.findByName(owner.getAccountId(), owner.getDomainId(), cmd.getName());

if (s == null) {

throw new InvalidParameterValueException("A key pair with name '" + cmd.getName() + "' does not exist for account " + owner.getAccountName()

+ " in specified domain id");

}

_accountMgr.checkAccess(caller, null, true, userVm);

String password = null;

String sshPublicKey = s.getPublicKey();

if (template != null && template.getEnablePassword()) {

password = _mgr.generateRandomPassword();

}

boolean result = resetVMSSHKeyInternal(vmId, sshPublicKey, password);

if (result) {

userVm.setDetail("SSH.PublicKey", sshPublicKey);

if (template != null && template.getEnablePassword()) {

userVm.setPassword(password);

//update the encrypted password in vm_details table too

encryptAndStorePassword(userVm, password);

}

_vmDao.saveDetails(userVm);

} else {

throw new CloudRuntimeException("Failed to reset SSH Key for the virtual machine ");

}

return userVm;

}

private boolean resetVMSSHKeyInternal(Long vmId, String sshPublicKey, String password) throws ResourceUnavailableException, InsufficientCapacityException {

Long userId = CallContext.current().getCallingUserId();

VMInstanceVO vmInstance = _vmDao.findById(vmId);

VMTemplateVO template = _templateDao.findByIdIncludingRemoved(vmInstance.getTemplateId());

Nic defaultNic = _networkModel.getDefaultNic(vmId);

if (defaultNic == null) {

s_logger.error("Unable to reset SSH Key for vm " + vmInstance + " as the instance doesn't have default nic");

return false;

}

Network defaultNetwork = _networkDao.findById(defaultNic.getNetworkId());

NicProfile defaultNicProfile = new NicProfile(defaultNic, defaultNetwork, null, null, null, _networkModel.isSecurityGroupSupportedInNetwork(defaultNetwork),

_networkModel.getNetworkTag(template.getHypervisorType(), defaultNetwork));

VirtualMachineProfile vmProfile = new VirtualMachineProfileImpl(vmInstance);

if (template.getEnablePassword()) {

vmProfile.setParameter(VirtualMachineProfile.Param.VmPassword, password);

}

UserDataServiceProvider element = _networkMgr.getSSHKeyResetProvider(defaultNetwork);

if (element == null) {

throw new CloudRuntimeException("Can't find network element for " + Service.UserData.getName() + " provider needed for SSH Key reset");

}

boolean result = element.saveSSHKey(defaultNetwork, defaultNicProfile, vmProfile, sshPublicKey);

// Need to reboot the virtual machine so that the password gets redownloaded from the DomR, and reset on the VM

if (!result) {

s_logger.debug("Failed to reset SSH Key for the virutal machine; no need to reboot the vm");

return false;

} else {

if (vmInstance.getState() == State.Stopped) {

s_logger.debug("Vm " + vmInstance + " is stopped, not rebooting it as a part of SSH Key reset");

return true;

}

if (rebootVirtualMachine(userId, vmId) == null) {

s_logger.warn("Failed to reboot the vm " + vmInstance);

return false;

} else {

s_logger.debug("Vm " + vmInstance + " is rebooted successfully as a part of SSH Key reset");

return true;

}

}

}

@Override

public boolean stopVirtualMachine(long userId, long vmId) {

boolean status = false;

if (s_logger.isDebugEnabled()) {

s_logger.debug("Stopping vm=" + vmId);

}

UserVmVO vm = _vmDao.findById(vmId);

if (vm == null || vm.getRemoved() != null) {

if (s_logger.isDebugEnabled()) {

s_logger.debug("VM is either removed or deleted.");

}

return true;

}

_userDao.findById(userId);

try {

VirtualMachineEntity vmEntity = _orchSrvc.getVirtualMachine(vm.getUuid());

status = vmEntity.stop(Long.toString(userId));

} catch (ResourceUnavailableException e) {

s_logger.debug("Unable to stop due to ", e);

status = false;

} catch (CloudException e) {

throw new CloudRuntimeException("Unable to contact the agent to stop the virtual machine " + vm, e);

}

return status;

}

private UserVm rebootVirtualMachine(long userId, long vmId) throws InsufficientCapacityException, ResourceUnavailableException {

UserVmVO vm = _vmDao.findById(vmId);

if (vm == null || vm.getState() == State.Destroyed || vm.getState() == State.Expunging || vm.getRemoved() != null) {

s_logger.warn("Vm id=" + vmId + " doesn't exist");

return null;

}

if (vm.getState() == State.Running && vm.getHostId() != null) {

collectVmDiskStatistics(vm);

DataCenterVO dc = _dcDao.findById(vm.getDataCenterId());

try {

if (dc.getNetworkType() == DataCenter.NetworkType.Advanced) {

//List all networks of vm

List<Long> vmNetworks = _vmNetworkMapDao.getNetworks(vmId);

List<DomainRouterVO> routers = new ArrayList<DomainRouterVO>();

//List the stopped routers

for(long vmNetworkId : vmNetworks) {

List<DomainRouterVO> router = _routerDao.listStopped(vmNetworkId);

routers.addAll(router);

}

//A vm may not have many nics attached and even fewer routers might be stopped (only in exceptional cases)

//Safe to start the stopped router serially, this is consistent with the way how multiple networks are added to vm during deploy

//and routers are started serially ,may revisit to make this process parallel

for(DomainRouterVO routerToStart : routers) {

s_logger.warn("Trying to start router " + routerToStart.getInstanceName() + " as part of vm: " + vm.getInstanceName() + " reboot");

_virtualNetAppliance.startRouter(routerToStart.getId(),true);

}

}

} catch (ConcurrentOperationException e) {

throw new CloudRuntimeException("Concurrent operations on starting router. " + e);

} catch (Exception ex){

throw new CloudRuntimeException("Router start failed due to" + ex);

}finally {

s_logger.info("Rebooting vm " + vm.getInstanceName());

_itMgr.reboot(vm.getUuid(), null);

}

return _vmDao.findById(vmId);

} else {

s_logger.error("Vm id=" + vmId + " is not in Running state, failed to reboot");

return null;

}

}

@Override

@ActionEvent(eventType = EventTypes.EVENT_VM_UPGRADE, eventDescription = "upgrading Vm")

/*

* TODO: cleanup eventually - Refactored API call

*/

// This method will be deprecated as we use ScaleVMCmd for both stopped VMs and running VMs

public UserVm upgradeVirtualMachine(UpgradeVMCmd cmd) throws ResourceAllocationException {

Long vmId = cmd.getId();

Long svcOffId = cmd.getServiceOfferingId();

Account caller = CallContext.current().getCallingAccount();

// Verify input parameters

//UserVmVO vmInstance = _vmDao.findById(vmId);

VMInstanceVO vmInstance = _vmInstanceDao.findById(vmId);

if (vmInstance == null) {

throw new InvalidParameterValueException("unable to find a virtual machine with id " + vmId);

} else if (!(vmInstance.getState().equals(State.Stopped))) {

throw new InvalidParameterValueException("Unable to upgrade virtual machine " + vmInstance.toString() + " " + " in state " + vmInstance.getState()

+ "; make sure the virtual machine is stopped");

}

// If target VM has associated VM snapshots then don't allow upgrading of VM

List<VMSnapshotVO> vmSnapshots = _vmSnapshotDao.findByVm(vmId);

if (vmSnapshots.size() > 0) {

throw new InvalidParameterValueException("Unable to change service offering for VM, please remove VM snapshots before changing service offering of VM");

}

_accountMgr.checkAccess(caller, null, true, vmInstance);

// Check resource limits for CPU and Memory.

Map<String, String> customParameters = cmd.getDetails();

ServiceOfferingVO newServiceOffering = _offeringDao.findById(svcOffId);

if (newServiceOffering.isDynamic()) {

newServiceOffering.setDynamicFlag(true);

validateCustomParameters(newServiceOffering, cmd.getDetails());

newServiceOffering = _offeringDao.getcomputeOffering(newServiceOffering, customParameters);

}

ServiceOfferingVO currentServiceOffering = _offeringDao.findByIdIncludingRemoved(vmInstance.getId(), vmInstance.getServiceOfferingId());

int newCpu = newServiceOffering.getCpu();

int newMemory = newServiceOffering.getRamSize();

int currentCpu = currentServiceOffering.getCpu();

int currentMemory = currentServiceOffering.getRamSize();

if (newCpu > currentCpu) {

_resourceLimitMgr.checkResourceLimit(caller, ResourceType.cpu, newCpu - currentCpu);

}

if (newMemory > currentMemory) {

_resourceLimitMgr.checkResourceLimit(caller, ResourceType.memory, newMemory - currentMemory);

}

// Check that the specified service offering ID is valid

_itMgr.checkIfCanUpgrade(vmInstance, newServiceOffering);

_itMgr.upgradeVmDb(vmId, svcOffId);

if (newServiceOffering.isDynamic()) {

//save the custom values to the database.

saveCustomOfferingDetails(vmId, newServiceOffering);

}

if (currentServiceOffering.isDynamic() && !newServiceOffering.isDynamic()) {

removeCustomOfferingDetails(vmId);

}

// Increment or decrement CPU and Memory count accordingly.

if (newCpu > currentCpu) {

_resourceLimitMgr.incrementResourceCount(caller.getAccountId(), ResourceType.cpu, new Long(newCpu - currentCpu));

} else if (currentCpu > newCpu) {

_resourceLimitMgr.decrementResourceCount(caller.getAccountId(), ResourceType.cpu, new Long(currentCpu - newCpu));

}

if (newMemory > currentMemory) {