// 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;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import javax.ejb.Local;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import org.apache.log4j.Logger;
import org.apache.cloudstack.storage.command.AttachCommand;
import org.apache.cloudstack.storage.command.CopyCommand;
import org.apache.cloudstack.storage.command.CreateObjectCommand;
import org.apache.cloudstack.storage.command.DeleteCommand;
import org.apache.cloudstack.storage.command.DettachCommand;
import org.apache.cloudstack.storage.command.StorageSubSystemCommand;
import com.cloud.agent.IAgentControl;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.AttachIsoCommand;
import com.cloud.agent.api.CheckHealthCommand;
import com.cloud.agent.api.CheckNetworkCommand;
import com.cloud.agent.api.CheckOnHostCommand;
import com.cloud.agent.api.CheckVirtualMachineCommand;
import com.cloud.agent.api.Command;
import com.cloud.agent.api.CreatePrivateTemplateFromVolumeCommand;
import com.cloud.agent.api.CreateStoragePoolCommand;
import com.cloud.agent.api.DeleteStoragePoolCommand;
import com.cloud.agent.api.FenceCommand;
import com.cloud.agent.api.GetHostStatsCommand;
import com.cloud.agent.api.GetStorageStatsCommand;
import com.cloud.agent.api.GetVmStatsCommand;
import com.cloud.agent.api.GetVncPortCommand;
import com.cloud.agent.api.MaintainCommand;
import com.cloud.agent.api.MigrateCommand;
import com.cloud.agent.api.ModifyStoragePoolCommand;
import com.cloud.agent.api.NetworkRulesSystemVmCommand;
import com.cloud.agent.api.NetworkUsageCommand;
import com.cloud.agent.api.PingCommand;
import com.cloud.agent.api.PingRoutingCommand;
import com.cloud.agent.api.PingTestCommand;
import com.cloud.agent.api.PlugNicCommand;
import com.cloud.agent.api.PrepareForMigrationCommand;
import com.cloud.agent.api.ReadyCommand;
import com.cloud.agent.api.RebootAnswer;
import com.cloud.agent.api.RebootCommand;
import com.cloud.agent.api.StartAnswer;
import com.cloud.agent.api.StartCommand;
import com.cloud.agent.api.StartupCommand;
import com.cloud.agent.api.StartupRoutingCommand;
import com.cloud.agent.api.StartupStorageCommand;
import com.cloud.agent.api.StopAnswer;
import com.cloud.agent.api.StopCommand;
import com.cloud.agent.api.UnPlugNicCommand;
import com.cloud.agent.api.check.CheckSshCommand;
import com.cloud.agent.api.routing.NetworkElementCommand;
import com.cloud.agent.api.storage.CopyVolumeCommand;
import com.cloud.agent.api.storage.CreateCommand;
import com.cloud.agent.api.storage.DestroyCommand;
import com.cloud.agent.api.storage.PrimaryStorageDownloadCommand;
import com.cloud.agent.api.to.NicTO;
import com.cloud.agent.api.to.VirtualMachineTO;
import com.cloud.agent.resource.virtualnetwork.VirtualRoutingResource;
import com.cloud.host.Host.Type;
import com.cloud.hypervisor.ovm3.objects.CloudstackPlugin;
import com.cloud.hypervisor.ovm3.objects.Common;
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.helpers.Ovm3Configuration;
import com.cloud.hypervisor.ovm3.resources.helpers.Ovm3HypervisorNetwork;
import com.cloud.hypervisor.ovm3.resources.helpers.Ovm3HypervisorSupport;
import com.cloud.hypervisor.ovm3.resources.helpers.Ovm3StoragePool;
import com.cloud.hypervisor.ovm3.resources.helpers.Ovm3VirtualRoutingSupport;
import com.cloud.hypervisor.ovm3.resources.helpers.Ovm3VmGuestTypes;
import com.cloud.hypervisor.ovm3.resources.helpers.Ovm3VmSupport;
import com.cloud.network.Networks.TrafficType;
import com.cloud.resource.ServerResourceBase;
import com.cloud.resource.hypervisor.HypervisorResource;
import com.cloud.storage.resource.StorageSubsystemCommandHandler;
import com.cloud.storage.resource.StorageSubsystemCommandHandlerBase;
import com.cloud.template.VirtualMachineTemplate.BootloaderType;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachine.State;
/**
* Hypervisor related
*/
@Local(value = HypervisorResource.class)
public class Ovm3HypervisorResource extends ServerResourceBase implements
HypervisorResource {
private static final Logger LOGGER = Logger
.getLogger(Ovm3HypervisorResource.class);
@Inject
private VirtualRoutingResource vrResource;
private StorageSubsystemCommandHandler storageHandler;
private Connection c;
private Ovm3StoragePool storagepool;
private Ovm3StorageProcessor storageprocessor;
private Ovm3HypervisorSupport hypervisorsupport;
private Ovm3VmSupport vmsupport;
private Ovm3HypervisorNetwork hypervisornetwork;
private Ovm3VirtualRoutingResource virtualroutingresource;
private Ovm3VirtualRoutingSupport virtualroutingsupport;
private Ovm3Configuration configuration;
private Ovm3VmGuestTypes guesttypes;
private final OvmObject ovmObject = new OvmObject();
/*
* TODO: Add a network map, so we know which tagged interfaces we can remove
* and switch to ConcurrentHashMap
*/
private final Map<String, Xen.Vm> vmMap = new HashMap<String, Xen.Vm>();
@Override
public Type getType() {
return Type.Routing;
}
/*
* configure is called before this, does setup of the connection and
* gets the params.
*
* @see com.cloud.resource.ServerResource#initialize()
*/
@Override
public StartupCommand[] initialize() {
LOGGER.debug("Ovm3 resource intializing");
try {
StartupRoutingCommand srCmd = new StartupRoutingCommand();
StartupStorageCommand ssCmd = new StartupStorageCommand();
/* here stuff gets completed, but where should state live ? */
hypervisorsupport.fillHostInfo(srCmd);
hypervisorsupport.vmStateMapClear();
LOGGER.debug("Ovm3 pool " + ssCmd + " " + srCmd);
return new StartupCommand[] { srCmd, ssCmd };
} catch (Exception e) {
LOGGER.debug("Ovm3 resource initializes failed", e);
return new StartupCommand[] {};
}
}
@Override
public PingCommand getCurrentStatus(long id) {
try {
/* feels useless somehow */
Common test = new Common(c);
String ping = "put";
String pong = test.echo(ping);
if (pong.contains(ping)) {
hypervisorsupport.syncState();
CloudstackPlugin cSp = new CloudstackPlugin(c);
if (!cSp.dom0CheckStorageHealthCheck(configuration .getAgentScriptsDir(),
configuration.getAgentCheckStorageScript(),
configuration.getCsHostGuid(),
configuration.getAgentStorageCheckTimeout(),
configuration.getAgentStorageCheckInterval())
&& !cSp.dom0CheckStorageHealthCheck()) {
LOGGER.error("Storage health check not running on "
+ configuration.getAgentHostname());
} else if (cSp.dom0CheckStorageHealthCheck()) {
LOGGER.error("Storage health check started on "
+ configuration.getAgentHostname());
} else {
LOGGER.debug("Storage health check running on "
+ configuration.getAgentHostname());
}
return new PingRoutingCommand(getType(), id,
hypervisorsupport.hostVmStateReport());
} else {
LOGGER.debug("Agent did not respond correctly: " + ping
+ " but got " + pong);
}
} catch (Ovm3ResourceException | NullPointerException e) {
LOGGER.debug("Check agent status failed", e);
return null;
}
return null;
}
@Override
public Answer executeRequest(Command cmd) {
Class<? extends Command> clazz = cmd.getClass();
LOGGER.debug("executeRequest called: " + cmd.getClass());
if (cmd instanceof NetworkElementCommand) {
return vrResource.executeRequest((NetworkElementCommand) cmd);
} else if (clazz == NetworkRulesSystemVmCommand.class) {
return virtualroutingsupport
.execute((NetworkRulesSystemVmCommand) cmd);
} else if (clazz == CheckSshCommand.class) {
return virtualroutingsupport.execute((CheckSshCommand) cmd);
} else if (clazz == NetworkUsageCommand.class) {
return virtualroutingsupport.execute((NetworkUsageCommand) cmd);
/* double check order! */
} else if (clazz == CopyCommand.class) {
return storageprocessor.execute((CopyCommand) cmd);
} else if (cmd instanceof StorageSubSystemCommand) {
return storageHandler.handleStorageCommands((StorageSubSystemCommand) cmd);
} else if (clazz == DeleteCommand.class) {
return storageprocessor.execute((DeleteCommand) cmd);
} else if (clazz == CreateCommand.class) {
return storageprocessor.execute((CreateCommand) cmd);
} else if (clazz == CreateObjectCommand.class) {
return storageprocessor.execute((CreateObjectCommand) cmd);
} else if (clazz == AttachIsoCommand.class) {
return storageprocessor.attachIso((AttachCommand) cmd);
} else if (clazz == DettachCommand.class) {
return storageprocessor.execute((DettachCommand) cmd);
} else if (clazz == AttachCommand.class) {
return storageprocessor.execute((AttachCommand) cmd);
} else if (clazz == CreatePrivateTemplateFromVolumeCommand.class) {
return storageprocessor
.execute((CreatePrivateTemplateFromVolumeCommand) cmd);
} else if (clazz == DestroyCommand.class) {
return storageprocessor.execute((DestroyCommand) cmd);
} else if (clazz == CopyVolumeCommand.class) {
return storageprocessor.execute((CopyVolumeCommand) cmd);
} else if (clazz == CreateStoragePoolCommand.class) {
return storagepool.execute((CreateStoragePoolCommand) cmd);
} else if (clazz == ModifyStoragePoolCommand.class) {
return storagepool.execute((ModifyStoragePoolCommand) cmd);
} else if (clazz == PrimaryStorageDownloadCommand.class) {
return storagepool.execute((PrimaryStorageDownloadCommand) cmd);
} else if (clazz == DeleteStoragePoolCommand.class) {
return storagepool.execute((DeleteStoragePoolCommand) cmd);
} else if (clazz == GetStorageStatsCommand.class) {
return storagepool.execute((GetStorageStatsCommand) cmd);
} else if (clazz == GetHostStatsCommand.class) {
return hypervisorsupport.execute((GetHostStatsCommand) cmd);
} else if (clazz == CheckVirtualMachineCommand.class) {
return hypervisorsupport.execute((CheckVirtualMachineCommand) cmd);
} else if (clazz == MaintainCommand.class) {
return hypervisorsupport.execute((MaintainCommand) cmd);
} else if (clazz == CheckHealthCommand.class) {
return hypervisorsupport.execute((CheckHealthCommand) cmd);
} else if (clazz == ReadyCommand.class) {
return hypervisorsupport.execute((ReadyCommand) cmd);
} else if (clazz == FenceCommand.class) {
return hypervisorsupport.execute((FenceCommand) cmd);
} else if (clazz == CheckOnHostCommand.class) {
return hypervisorsupport.execute((CheckOnHostCommand)cmd);
} else if (clazz == PingTestCommand.class) {
return hypervisornetwork.execute((PingTestCommand) cmd);
} else if (clazz == CheckNetworkCommand.class) {
return hypervisornetwork.execute((CheckNetworkCommand) cmd);
} else if (clazz == GetVmStatsCommand.class) {
return vmsupport.execute((GetVmStatsCommand) cmd);
} else if (clazz == PrepareForMigrationCommand.class) {
return vmsupport.execute((PrepareForMigrationCommand) cmd);
} else if (clazz == MigrateCommand.class) {
return vmsupport.execute((MigrateCommand) cmd);
} else if (clazz == GetVncPortCommand.class) {
return vmsupport.execute((GetVncPortCommand) cmd);
} else if (clazz == PlugNicCommand.class) {
return vmsupport.execute((PlugNicCommand) cmd);
} else if (clazz == UnPlugNicCommand.class) {
return vmsupport.execute((UnPlugNicCommand) cmd);
} else if (clazz == StartCommand.class) {
return execute((StartCommand) cmd);
} else if (clazz == StopCommand.class) {
return execute((StopCommand) cmd);
} else if (clazz == RebootCommand.class) {
return execute((RebootCommand) cmd);
}
LOGGER.debug("Can't find class for executeRequest " + cmd.getClass() +", is your direct call missing?");
return Answer.createUnsupportedCommandAnswer(cmd);
}
@Override
public void disconnected() {
LOGGER.debug("disconnected seems unused everywhere else");
}
@Override
public IAgentControl getAgentControl() {
LOGGER.debug("we don't use IAgentControl");
return null;
}
@Override
public void setAgentControl(IAgentControl agentControl) {
LOGGER.debug("No use in setting IAgentControl");
}
@Override
public String getName() {
return configuration.getAgentName();
}
@Override
public void setName(String name) {
configuration.setAgentName(name);
}
@Override
public void setConfigParams(Map<String, Object> params) {
configuration.setRawParams(params);
}
@Override
public Map<String, Object> getConfigParams() {
return configuration.getRawParams();
}
@Override
public int getRunLevel() {
return 0;
}
@Override
public void setRunLevel(int level) {
LOGGER.debug("runlevel seems unused in other hypervisors");
}
/**
* Base configuration of the plugins components.
*/
@Override
public boolean configure(String name, Map<String, Object> params)
throws ConfigurationException {
LOGGER.debug("configure " + name + " with params: " + params);
/* check if we're master or not and if we can connect */
try {
configuration = new Ovm3Configuration(params);
if (!configuration.getIsTest()) {
c = new Connection(configuration.getAgentIp(),
configuration.getAgentOvsAgentPort(),
configuration.getAgentOvsAgentUser(),
configuration.getAgentOvsAgentPassword());
c.setHostName(configuration.getAgentHostname());
}
hypervisorsupport = new Ovm3HypervisorSupport(c, configuration);
if (!configuration.getIsTest()) {
hypervisorsupport.setupServer(configuration
.getAgentSshKeyFileName());
}
hypervisorsupport.masterCheck();
} catch (Exception e) {
throw new CloudRuntimeException("Base checks failed for "
+ configuration.getAgentHostname(), e);
}
hypervisornetwork = new Ovm3HypervisorNetwork(c, configuration);
hypervisornetwork.configureNetworking();
virtualroutingresource = new Ovm3VirtualRoutingResource(c);
storagepool = new Ovm3StoragePool(c, configuration);
storagepool.prepareForPool();
storageprocessor = new Ovm3StorageProcessor(c, configuration,
storagepool);
vmsupport = new Ovm3VmSupport(c, configuration, hypervisorsupport,
storageprocessor, storagepool, hypervisornetwork);
vrResource = new VirtualRoutingResource(virtualroutingresource);
if (!vrResource.configure(name, params)) {
throw new ConfigurationException(
"Unable to configure VirtualRoutingResource");
}
guesttypes = new Ovm3VmGuestTypes();
storageHandler = new StorageSubsystemCommandHandlerBase(storageprocessor);
virtualroutingsupport = new Ovm3VirtualRoutingSupport(c, configuration,
virtualroutingresource);
setConfigParams(params);
return true;
}
public void setConnection(Connection con) {
LOGGER.debug("override connection: " + con.getIp());
c = con;
}
@Override
public boolean start() {
return true;
}
@Override
public boolean stop() {
return true;
}
@Override
public synchronized StartAnswer execute(StartCommand cmd) {
VirtualMachineTO vmSpec = cmd.getVirtualMachine();
String vmName = vmSpec.getName();
State state = State.Stopped;
Xen xen = new Xen(c);
try {
hypervisorsupport.setVmStateStarting(vmName);
Xen.Vm vm = xen.getVmConfig();
/* max and min ? */
vm.setVmCpus(vmSpec.getCpus());
/* in mb not in bytes */
vm.setVmMemory(vmSpec.getMinRam() / 1024 / 1024);
vm.setVmUuid(UUID.nameUUIDFromBytes(vmSpec.getName().
getBytes(Charset.defaultCharset())).toString());
vm.setVmName(vmName);
String domType = guesttypes.getOvm3GuestType(vmSpec.getOs());
if (domType == null || domType.isEmpty()) {
domType = "default";
LOGGER.debug("VM Virt type missing setting to: " + domType);
} else {
LOGGER.debug("VM Virt type set to " + domType + " for "
+ vmSpec.getOs());
}
vm.setVmDomainType(domType);
if (vmSpec.getBootloader() == BootloaderType.CD) {
LOGGER.warn("CD booting is not supported");
}
/*
* officially CD boot is only supported on HVM, although there is a
* simple way around it..
*/
vmsupport.createVbds(vm, vmSpec);
if (vmSpec.getType() != VirtualMachine.Type.User) {
// double check control network if we run a non user VM
hypervisornetwork.configureNetworking();
vm.setVmExtra(vmSpec.getBootArgs().replace(" ", "%"));
String svmPath = configuration.getAgentOvmRepoPath() + "/"
+ ovmObject.deDash(vm.getPrimaryPoolUuid()) + "/ISOs";
String svmIso = svmPath + "/"
+ storagepool.getSystemVMPatchIsoFile().getName();
vm.addIso(svmIso);
}
/* OVS/Network stuff should go here! */
vmsupport.createVifs(vm, vmSpec);
vm.setupVifs();
vm.setVnc("0.0.0.0", vmSpec.getVncPassword());
xen.createVm(ovmObject.deDash(vm.getPrimaryPoolUuid()),
vm.getVmUuid());
xen.startVm(ovmObject.deDash(vm.getPrimaryPoolUuid()),
vm.getVmUuid());
state = State.Running;
if (vmSpec.getType() != VirtualMachine.Type.User) {
String controlIp = null;
for (NicTO nic : vmSpec.getNics()) {
if (nic.getType() == TrafficType.Control) {
controlIp = nic.getIp();
}
}
/* fix is in cloudstack.py for xend restart timer */
for (int count = 0; count < 60; count++) {
CloudstackPlugin cSp = new CloudstackPlugin(c);
/* skip a beat to make sure we didn't miss start */
if (hypervisorsupport.getVmState(vmName) == null && count > 1) {
String msg = "VM " + vmName + " went missing on "
+ configuration.getAgentHostname()
+ ", returning stopped";
LOGGER.debug(msg);
state = State.Stopped;
return new StartAnswer(cmd, msg);
}
/* creative fix? */
try {
Boolean res = cSp.domrCheckSsh(controlIp);
LOGGER.debug("connected to " + controlIp
+ " on attempt " + count + " result: " + res);
if (res) {
break;
}
} catch (Exception x) {
LOGGER.trace(
"unable to connect to " + controlIp
+ " on attempt " + count + " "
+ x.getMessage(), x);
}
Thread.sleep(5000);
}
}
/*
* Can't remember if HA worked if we were only a pool ?
*/
if (configuration.getAgentInOvm3Pool()
&& configuration.getAgentInOvm3Cluster()) {
xen.configureVmHa(ovmObject.deDash(vm.getPrimaryPoolUuid()),
vm.getVmUuid(), true);
}
/* should be starting no ? */
state = State.Running;
return new StartAnswer(cmd);
} catch (Exception e) {
LOGGER.debug("Start vm " + vmName + " failed", e);
state = State.Stopped;
return new StartAnswer(cmd, e.getMessage());
} finally {
hypervisorsupport.setVmState(vmName, state);
}
}
/**
* Removes the vm and its configuration from the hypervisor.
*/
@Override
public StopAnswer execute(StopCommand cmd) {
String vmName = cmd.getVmName();
State state = State.Error;
hypervisorsupport.setVmState(vmName, State.Stopping);
try {
Xen vms = new Xen(c);
Xen.Vm vm = null;
vm = vms.getRunningVmConfig(vmName);
if (vm == null) {
state = State.Stopping;
LOGGER.debug("Unable to get details of vm: " + vmName
+ ", treating it as Stopping");
return new StopAnswer(cmd, "success", true);
}
String repoId = ovmObject.deDash(vm.getVmRootDiskPoolId());
String vmId = vm.getVmUuid();
/* can we do without the poolId ? */
vms.stopVm(repoId, vmId);
int tries = 30;
while (vms.getRunningVmConfig(vmName) != null && tries > 0) {
String msg = "Waiting for " + vmName + " to stop";
LOGGER.debug(msg);
tries--;
Thread.sleep(10 * 1000);
}
vms.deleteVm(repoId, vmId);
vmsupport.cleanup(vm);
if (vms.getRunningVmConfig(vmName) != null) {
String msg = "Stop " + vmName + " failed ";
LOGGER.debug(msg);
return new StopAnswer(cmd, msg, false);
}
state = State.Stopped;
return new StopAnswer(cmd, "success", true);
} catch (Exception e) {
LOGGER.debug("Stop " + vmName + " failed ", e);
return new StopAnswer(cmd, e.getMessage(), false);
} finally {
if (state != null) {
hypervisorsupport.setVmState(vmName, state);
} else {
hypervisorsupport.revmoveVmState(vmName);
}
}
}
@Override
public RebootAnswer execute(RebootCommand cmd) {
String vmName = cmd.getVmName();
hypervisorsupport.setVmStateStarting(vmName);
try {
Xen xen = new Xen(c);
Xen.Vm vm = xen.getRunningVmConfig(vmName);
if (vm == null) {
return new RebootAnswer(cmd, vmName + " not present", false);
}
xen.rebootVm(ovmObject.deDash(vm.getVmRootDiskPoolId()),
vm.getVmUuid());
vm = xen.getRunningVmConfig(vmName);
Integer vncPort = vm.getVncPort();
return new RebootAnswer(cmd, null, vncPort);
} catch (Exception e) {
LOGGER.debug("Reboot " + vmName + " failed", e);
return new RebootAnswer(cmd, e.getMessage(), false);
} finally {
hypervisorsupport.setVmState(vmName, State.Running);
}
}
@Override
protected String getDefaultScriptsDir() {
return null;
}
}