| // 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.hypervisor.ovm3.resources.helpers; |
| |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.ConcurrentHashMap; |
| |
| import org.apache.cloudstack.storage.to.TemplateObjectTO; |
| import org.apache.cloudstack.storage.to.VolumeObjectTO; |
| import org.apache.log4j.Logger; |
| import org.apache.xmlrpc.XmlRpcException; |
| |
| import com.cloud.agent.api.Answer; |
| import com.cloud.agent.api.GetVmStatsAnswer; |
| import com.cloud.agent.api.GetVmStatsCommand; |
| import com.cloud.agent.api.GetVncPortAnswer; |
| import com.cloud.agent.api.GetVncPortCommand; |
| import com.cloud.agent.api.MigrateAnswer; |
| import com.cloud.agent.api.MigrateCommand; |
| import com.cloud.agent.api.PlugNicAnswer; |
| import com.cloud.agent.api.PlugNicCommand; |
| import com.cloud.agent.api.PrepareForMigrationAnswer; |
| import com.cloud.agent.api.PrepareForMigrationCommand; |
| import com.cloud.agent.api.UnPlugNicAnswer; |
| import com.cloud.agent.api.UnPlugNicCommand; |
| import com.cloud.agent.api.VmStatsEntry; |
| import com.cloud.agent.api.to.DataStoreTO; |
| import com.cloud.agent.api.to.DataTO; |
| import com.cloud.agent.api.to.DiskTO; |
| import com.cloud.agent.api.to.NfsTO; |
| import com.cloud.agent.api.to.NicTO; |
| import com.cloud.agent.api.to.VirtualMachineTO; |
| import com.cloud.host.HostVO; |
| import com.cloud.hypervisor.ovm3.objects.CloudstackPlugin; |
| import com.cloud.hypervisor.ovm3.objects.Connection; |
| import com.cloud.hypervisor.ovm3.objects.Ovm3ResourceException; |
| import com.cloud.hypervisor.ovm3.objects.OvmObject; |
| import com.cloud.hypervisor.ovm3.objects.Xen; |
| import com.cloud.hypervisor.ovm3.resources.Ovm3StorageProcessor; |
| import com.cloud.resource.ResourceManager; |
| import com.cloud.storage.Volume; |
| import com.cloud.utils.exception.CloudRuntimeException; |
| import com.cloud.vm.VirtualMachine.State; |
| |
| public class Ovm3VmSupport { |
| private final Logger LOGGER = Logger.getLogger(Ovm3VmSupport.class); |
| private OvmObject ovmObject = new OvmObject(); |
| private ResourceManager resourceMgr; |
| private Connection c; |
| private Ovm3HypervisorNetwork network; |
| private Ovm3Configuration config; |
| private Ovm3HypervisorSupport hypervisor; |
| private Ovm3StorageProcessor processor; |
| private Ovm3StoragePool pool; |
| private final Map<String, Map<String, String>> vmStats = new ConcurrentHashMap<String, Map<String, String>>(); |
| public Ovm3VmSupport(Connection conn, |
| Ovm3Configuration ovm3config, |
| Ovm3HypervisorSupport ovm3hyper, |
| Ovm3StorageProcessor ovm3stp, |
| Ovm3StoragePool ovm3sp, |
| Ovm3HypervisorNetwork ovm3hvn) { |
| c = conn; |
| config = ovm3config; |
| hypervisor = ovm3hyper; |
| pool = ovm3sp; |
| processor = ovm3stp; |
| network = ovm3hvn; |
| } |
| public Boolean createVifs(Xen.Vm vm, VirtualMachineTO spec) |
| throws Ovm3ResourceException { |
| if (spec.getNics() != null) { |
| NicTO[] nics = spec.getNics(); |
| return createVifs(vm, nics); |
| } else { |
| LOGGER.info("No nics for vm " + spec.getName()); |
| return false; |
| } |
| } |
| |
| private Boolean createVifs(Xen.Vm vm, NicTO[] nics) |
| throws Ovm3ResourceException { |
| for (NicTO nic : nics) { |
| if (!createVif(vm, nic)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /* should add bitrates and latency... */ |
| private Boolean createVif(Xen.Vm vm, NicTO nic) |
| throws Ovm3ResourceException { |
| try { |
| String net = network.getNetwork(nic); |
| if (net != null) { |
| LOGGER.debug("Adding vif " + nic.getDeviceId() + " " |
| + nic.getMac() + " " + net + " to " + vm.getVmName()); |
| vm.addVif(nic.getDeviceId(), net, nic.getMac()); |
| } else { |
| LOGGER.debug("Unable to add vif " + nic.getDeviceId() |
| + " no network for " + vm.getVmName()); |
| return false; |
| } |
| } catch (Exception e) { |
| String msg = "Unable to add vif " + nic.getType() + " for " |
| + vm.getVmName() + " " + e.getMessage(); |
| LOGGER.debug(msg); |
| throw new Ovm3ResourceException(msg); |
| } |
| return true; |
| } |
| private Boolean deleteVif(Xen.Vm vm, NicTO nic) |
| throws Ovm3ResourceException { |
| /* here we should use the housekeeping of VLANs/Networks etc.. |
| * so we can clean after the last VM is gone |
| */ |
| try { |
| String net = network.getNetwork(nic); |
| if (net != null) { |
| LOGGER.debug("Removing vif " + nic.getDeviceId() + " " + " " |
| + nic.getMac() + " " + net + " from " + vm.getVmName()); |
| vm.removeVif(net, nic.getMac()); |
| } else { |
| LOGGER.debug("Unable to remove vif " + nic.getDeviceId() |
| + " no network for " + vm.getVmName()); |
| return false; |
| } |
| } catch (Exception e) { |
| String msg = "Unable to remove vif " + nic.getType() + " for " |
| + vm.getVmName() + " " + e.getMessage(); |
| LOGGER.debug(msg); |
| throw new Ovm3ResourceException(msg); |
| } |
| return true; |
| } |
| |
| /* Migration should make sure both HVs are the same ? */ |
| public PrepareForMigrationAnswer execute(PrepareForMigrationCommand cmd) { |
| VirtualMachineTO vm = cmd.getVirtualMachine(); |
| if (LOGGER.isDebugEnabled()) { |
| LOGGER.debug("Preparing host for migrating " + vm.getName()); |
| } |
| NicTO[] nics = vm.getNics(); |
| try { |
| for (NicTO nic : nics) { |
| network.getNetwork(nic); |
| } |
| hypervisor.setVmState(vm.getName(), State.Migrating); |
| LOGGER.debug("VM " + vm.getName() + " is in Migrating state"); |
| return new PrepareForMigrationAnswer(cmd); |
| } catch (Ovm3ResourceException e) { |
| LOGGER.error("Catch Exception " + e.getClass().getName() |
| + " prepare for migration failed due to: " + e.getMessage()); |
| return new PrepareForMigrationAnswer(cmd, e); |
| } |
| } |
| |
| /* do migrations of VMs in a simple way just inside a cluster for now */ |
| public MigrateAnswer execute(final MigrateCommand cmd) { |
| final String vmName = cmd.getVmName(); |
| String destUuid = cmd.getHostGuid(); |
| String destIp = cmd.getDestinationIp(); |
| State state = State.Error; |
| /* |
| * TODO: figure out non pooled migration, works from CLI but not from |
| * the agent... perhaps pause the VM and then migrate it ? for now just |
| * stop the VM. |
| */ |
| String msg = "Migrating " + vmName + " to " + destIp; |
| LOGGER.info(msg); |
| if (!config.getAgentInOvm3Cluster() && !config.getAgentInOvm3Pool()) { |
| try { |
| Xen xen = new Xen(c); |
| Xen.Vm vm = xen.getRunningVmConfig(vmName); |
| HostVO destHost = resourceMgr.findHostByGuid(destUuid); |
| if (destHost == null) { |
| msg = "Unable to find migration target host in DB " |
| + destUuid + " with ip " + destIp; |
| LOGGER.info(msg); |
| return new MigrateAnswer(cmd, false, msg, null); |
| } |
| xen.stopVm(ovmObject.deDash(vm.getVmRootDiskPoolId()), |
| vm.getVmUuid()); |
| msg = destHost.toString(); |
| state = State.Stopping; |
| return new MigrateAnswer(cmd, false, msg, null); |
| } catch (Ovm3ResourceException e) { |
| msg = "Unpooled VM Migrate of " + vmName + " to " + destUuid |
| + " failed due to: " + e.getMessage(); |
| LOGGER.debug(msg, e); |
| return new MigrateAnswer(cmd, false, msg, null); |
| } finally { |
| /* shouldn't we just reinitialize completely as a last resort ? */ |
| hypervisor.setVmState(vmName, state); |
| } |
| } else { |
| try { |
| Xen xen = new Xen(c); |
| Xen.Vm vm = xen.getRunningVmConfig(vmName); |
| if (vm == null) { |
| state = State.Stopped; |
| msg = vmName + " is no running on " + config.getAgentHostname(); |
| return new MigrateAnswer(cmd, false, msg, null); |
| } |
| /* not a storage migration!!! */ |
| xen.migrateVm(ovmObject.deDash(vm.getVmRootDiskPoolId()), |
| vm.getVmUuid(), destIp); |
| state = State.Stopping; |
| msg = "Migration of " + vmName + " successful"; |
| return new MigrateAnswer(cmd, true, msg, null); |
| } catch (Ovm3ResourceException e) { |
| msg = "Pooled VM Migrate" + ": Migration of " + vmName + " to " |
| + destIp + " failed due to " + e.getMessage(); |
| LOGGER.debug(msg, e); |
| return new MigrateAnswer(cmd, false, msg, null); |
| } finally { |
| hypervisor.setVmState(vmName, state); |
| } |
| } |
| } |
| |
| /* |
| */ |
| public GetVncPortAnswer execute(GetVncPortCommand cmd) { |
| try { |
| Xen host = new Xen(c); |
| Xen.Vm vm = host.getRunningVmConfig(cmd.getName()); |
| Integer vncPort = vm.getVncPort(); |
| LOGGER.debug("get vnc port for " + cmd.getName() + ": " + vncPort); |
| return new GetVncPortAnswer(cmd, c.getIp(), vncPort); |
| } catch (Ovm3ResourceException e) { |
| LOGGER.debug("get vnc port for " + cmd.getName() + " failed", e); |
| return new GetVncPortAnswer(cmd, e.getMessage()); |
| } |
| } |
| |
| private VmStatsEntry getVmStat(String vmName) { |
| CloudstackPlugin cSp = new CloudstackPlugin(c); |
| Map<String, String> oldVmStats = null; |
| Map<String, String> newVmStats = null; |
| VmStatsEntry stats = new VmStatsEntry(); |
| try { |
| if (vmStats.containsKey(vmName)) { |
| oldVmStats = new HashMap<String, String>(); |
| oldVmStats.putAll(vmStats.get(vmName)); |
| } |
| newVmStats = cSp.ovsDomUStats(vmName); |
| } catch (Ovm3ResourceException e) { |
| LOGGER.info("Unable to retrieve stats from " + vmName, e); |
| return stats; |
| } |
| if (oldVmStats == null) { |
| LOGGER.debug("No old stats retrieved stats from " + vmName); |
| stats.setNumCPUs(1); |
| stats.setNetworkReadKBs(0); |
| stats.setNetworkWriteKBs(0); |
| stats.setDiskReadKBs(0); |
| stats.setDiskWriteKBs(0); |
| stats.setDiskReadIOs(0); |
| stats.setDiskWriteIOs(0); |
| stats.setCPUUtilization(0); |
| stats.setEntityType("vm"); |
| } else { |
| LOGGER.debug("Retrieved new stats from " + vmName); |
| int cpus = Integer.parseInt(newVmStats.get("vcpus")); |
| stats.setNumCPUs(cpus); |
| stats.setNetworkReadKBs(doubleMin(newVmStats.get("rx_bytes"), oldVmStats.get("rx_bytes"))); |
| stats.setNetworkWriteKBs(doubleMin(newVmStats.get("tx_bytes"), oldVmStats.get("tx_bytes"))); |
| stats.setDiskReadKBs(doubleMin(newVmStats.get("rd_bytes"), oldVmStats.get("rd_bytes"))); |
| stats.setDiskWriteKBs(doubleMin(newVmStats.get("rw_bytes"), oldVmStats.get("rw_bytes"))); |
| stats.setDiskReadIOs(doubleMin(newVmStats.get("rd_ops"), oldVmStats.get("rd_ops"))); |
| stats.setDiskWriteIOs(doubleMin(newVmStats.get("rw_ops"), oldVmStats.get("rw_ops"))); |
| Double dCpu = doubleMin(newVmStats.get("cputime"), oldVmStats.get("cputime")); |
| Double dTime = doubleMin(newVmStats.get("uptime"), oldVmStats.get("uptime")); |
| Double cpupct = dCpu / dTime * 100 * cpus; |
| stats.setCPUUtilization(cpupct); |
| stats.setEntityType("vm"); |
| } |
| ((ConcurrentHashMap<String, Map<String, String>>) vmStats).put( |
| vmName, newVmStats); |
| return stats; |
| } |
| private Double doubleMin(String x, String y) { |
| try { |
| return (Double.parseDouble(x) - Double.parseDouble(y)); |
| } catch (NullPointerException e) { |
| return 0D; |
| } |
| } |
| |
| public GetVmStatsAnswer execute(GetVmStatsCommand cmd) { |
| List<String> vmNames = cmd.getVmNames(); |
| Map<String, VmStatsEntry> vmStatsNameMap = new HashMap<String, VmStatsEntry>(); |
| for (String vmName : vmNames) { |
| VmStatsEntry e = getVmStat(vmName); |
| vmStatsNameMap.put(vmName, e); |
| } |
| return new GetVmStatsAnswer(cmd, |
| (HashMap<String, VmStatsEntry>) vmStatsNameMap); |
| } |
| |
| /* This is not create for us, but really start */ |
| /* |
| public boolean startVm(String repoId, String vmId) throws XmlRpcException { |
| Xen host = new Xen(c); |
| try { |
| if (host.getRunningVmConfig(vmId) == null) { |
| LOGGER.error("Create VM " + vmId + " first on " + c.getIp()); |
| return false; |
| } else { |
| LOGGER.info("VM " + vmId + " exists on " + c.getIp()); |
| } |
| host.startVm(repoId, vmId); |
| } catch (Exception e) { |
| LOGGER.error("Failed to start VM " + vmId + " on " + c.getIp() |
| + " " + e.getMessage()); |
| return false; |
| } |
| return true; |
| } |
| */ |
| /* |
| * TODO: OVM already cleans stuff up, just not the extra bridges which we |
| * don't want right now, as we'd have to keep a state table of which vlans |
| * need to stay on the host!? A map with vlanid -> list-o-hosts |
| */ |
| private void cleanupNetwork(List<String> vifs) throws XmlRpcException { |
| /* peel out vif info for vlan stuff */ |
| } |
| |
| public void cleanup(Xen.Vm vm) { |
| try { |
| cleanupNetwork(vm.getVmVifs()); |
| } catch (XmlRpcException e) { |
| LOGGER.info("Clean up network for " + vm.getVmName() + " failed", e); |
| } |
| String vmName = vm.getVmName(); |
| /* should become a single entity */ |
| vmStats.remove(vmName); |
| } |
| |
| /* |
| * Add rootdisk, datadisk and iso's |
| */ |
| public Boolean createVbds(Xen.Vm vm, VirtualMachineTO spec) { |
| if (spec.getDisks() == null) { |
| LOGGER.info("No disks defined for " + vm.getVmName()); |
| return false; |
| } |
| for (DiskTO disk : spec.getDisks()) { |
| try { |
| if (disk.getType() == Volume.Type.ROOT) { |
| VolumeObjectTO vol = (VolumeObjectTO) disk.getData(); |
| String diskFile = processor.getVirtualDiskPath(vol.getUuid(), vol.getDataStore().getUuid()); |
| vm.addRootDisk(diskFile); |
| vm.setPrimaryPoolUuid(vol.getDataStore().getUuid()); |
| LOGGER.debug("Adding root disk: " + diskFile); |
| } else if (disk.getType() == Volume.Type.ISO) { |
| DataTO isoTO = disk.getData(); |
| if (isoTO.getPath() != null) { |
| TemplateObjectTO template = (TemplateObjectTO) isoTO; |
| DataStoreTO store = template.getDataStore(); |
| if (!(store instanceof NfsTO)) { |
| throw new CloudRuntimeException( |
| "unsupported protocol"); |
| } |
| NfsTO nfsStore = (NfsTO) store; |
| String secPoolUuid = pool.setupSecondaryStorage(nfsStore |
| .getUrl()); |
| String isoPath = config.getAgentSecStoragePath() + "/" |
| + secPoolUuid + "/" |
| + template.getPath(); |
| vm.addIso(isoPath); |
| /* check if secondary storage is mounted */ |
| LOGGER.debug("Adding ISO: " + isoPath); |
| } |
| } else if (disk.getType() == Volume.Type.DATADISK) { |
| VolumeObjectTO vol = (VolumeObjectTO) disk.getData(); |
| String diskFile = processor.getVirtualDiskPath(vol.getUuid(), vol.getDataStore().getUuid()); |
| vm.addDataDisk(diskFile); |
| LOGGER.debug("Adding data disk: " |
| + diskFile); |
| } else { |
| throw new CloudRuntimeException("Unknown disk type: " |
| + disk.getType()); |
| } |
| } catch (Exception e) { |
| LOGGER.debug("CreateVbds failed", e); |
| throw new CloudRuntimeException("Exception" + e.getMessage(), e); |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Implements the unplug and plug feature for Nics, the boolan decides |
| * to either plug (true) or unplug (false) |
| * |
| * @param nic |
| * @param vmName |
| * @param plug |
| * @return |
| */ |
| private Answer plugNunplugNic(NicTO nic, String vmName, Boolean plug) { |
| try { |
| Xen xen = new Xen(c); |
| Xen.Vm vm = xen.getVmConfig(vmName); |
| /* check running */ |
| if (vm == null) { |
| return new Answer(null, false, |
| "Unable to execute command due to missing VM"); |
| } |
| // setup the NIC in the VM config. |
| if (plug) { |
| createVif(vm, nic); |
| vm.setupVifs(); |
| } else { |
| deleteVif(vm, nic); |
| } |
| // execute the change |
| xen.configureVm(ovmObject.deDash(vm.getPrimaryPoolUuid()), |
| vm.getVmUuid()); |
| } catch (Ovm3ResourceException e) { |
| String msg = "Unable to execute command due to " + e.toString(); |
| LOGGER.debug(msg); |
| return new Answer(null, false, msg); |
| } |
| return new Answer(null, true, "success"); |
| } |
| /** |
| * PlugNicAnswer: plug a network interface into a VM |
| * @param cmd |
| * @return |
| */ |
| public PlugNicAnswer execute(PlugNicCommand cmd) { |
| Answer ans = plugNunplugNic(cmd.getNic(), cmd.getVmName(), true); |
| return new PlugNicAnswer(cmd, ans.getResult(), ans.getDetails()); |
| } |
| |
| /** |
| * UnPlugNicAnswer: remove a nic from a VM |
| * @param cmd |
| * @return |
| */ |
| public UnPlugNicAnswer execute(UnPlugNicCommand cmd) { |
| Answer ans = plugNunplugNic(cmd.getNic(), cmd.getVmName(), false); |
| return new UnPlugNicAnswer(cmd, ans.getResult(), ans.getDetails()); |
| } |
| } |
