mirror of https://github.com/apache/cloudstack.git
308 lines
12 KiB
Java
308 lines
12 KiB
Java
/**
|
|
* Copyright (C) 2010 Cloud.com, Inc. All rights reserved.
|
|
*
|
|
* This software is licensed under the GNU General Public License v3 or later.
|
|
*
|
|
* It is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
package com.cloud.vm;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import javax.ejb.Local;
|
|
import javax.naming.ConfigurationException;
|
|
|
|
import org.apache.log4j.Logger;
|
|
|
|
import com.cloud.agent.AgentManager;
|
|
import com.cloud.agent.api.Start2Answer;
|
|
import com.cloud.agent.api.Start2Command;
|
|
import com.cloud.agent.api.to.NicTO;
|
|
import com.cloud.agent.api.to.VirtualMachineTO;
|
|
import com.cloud.agent.api.to.VolumeTO;
|
|
import com.cloud.configuration.Config;
|
|
import com.cloud.configuration.dao.ConfigurationDao;
|
|
import com.cloud.deploy.DeployDestination;
|
|
import com.cloud.deploy.DeploymentPlan;
|
|
import com.cloud.deploy.DeploymentPlanner;
|
|
import com.cloud.exception.AgentUnavailableException;
|
|
import com.cloud.exception.ConcurrentOperationException;
|
|
import com.cloud.exception.InsufficientCapacityException;
|
|
import com.cloud.exception.OperationTimedoutException;
|
|
import com.cloud.exception.StorageUnavailableException;
|
|
import com.cloud.network.NetworkConfigurationVO;
|
|
import com.cloud.network.NetworkManager;
|
|
import com.cloud.offering.ServiceOffering;
|
|
import com.cloud.service.ServiceOfferingVO;
|
|
import com.cloud.service.dao.ServiceOfferingDao;
|
|
import com.cloud.storage.DiskOfferingVO;
|
|
import com.cloud.storage.GuestOSVO;
|
|
import com.cloud.storage.Storage;
|
|
import com.cloud.storage.Storage.ImageFormat;
|
|
import com.cloud.storage.StorageManager;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.Volume.VolumeType;
|
|
import com.cloud.storage.dao.GuestOSDao;
|
|
import com.cloud.storage.dao.VMTemplateDao;
|
|
import com.cloud.template.VirtualMachineTemplate.BootloaderType;
|
|
import com.cloud.user.AccountVO;
|
|
import com.cloud.utils.Journal;
|
|
import com.cloud.utils.NumbersUtil;
|
|
import com.cloud.utils.Pair;
|
|
import com.cloud.utils.component.Adapters;
|
|
import com.cloud.utils.component.ComponentLocator;
|
|
import com.cloud.utils.component.Inject;
|
|
import com.cloud.utils.db.DB;
|
|
import com.cloud.utils.db.Transaction;
|
|
import com.cloud.utils.exception.CloudRuntimeException;
|
|
import com.cloud.vm.VirtualMachine.Event;
|
|
import com.cloud.vm.dao.VMInstanceDao;
|
|
|
|
@Local(value=VmManager.class)
|
|
public class MauriceMoss implements VmManager {
|
|
private static final Logger s_logger = Logger.getLogger(MauriceMoss.class);
|
|
|
|
String _name;
|
|
@Inject private StorageManager _storageMgr;
|
|
@Inject private NetworkManager _networkMgr;
|
|
@Inject private AgentManager _agentMgr;
|
|
@Inject private VMInstanceDao _vmDao;
|
|
@Inject private ServiceOfferingDao _offeringDao;
|
|
@Inject private GuestOSDao _guestOsDao;
|
|
@Inject private VMTemplateDao _templateDao;
|
|
|
|
@Inject(adapter=DeploymentPlanner.class)
|
|
private Adapters<DeploymentPlanner> _planners;
|
|
|
|
private int _retry;
|
|
|
|
@Override @DB
|
|
public <T extends VMInstanceVO> VirtualMachineProfile allocate(T vm,
|
|
VMTemplateVO template,
|
|
ServiceOfferingVO serviceOffering,
|
|
Pair<? extends DiskOfferingVO, Long> rootDiskOffering,
|
|
List<Pair<DiskOfferingVO, Long>> dataDiskOfferings,
|
|
List<Pair<NetworkConfigurationVO, NicProfile>> networks,
|
|
DeploymentPlan plan,
|
|
AccountVO owner) throws InsufficientCapacityException {
|
|
if (s_logger.isDebugEnabled()) {
|
|
s_logger.debug("Allocating entries for VM: " + vm);
|
|
}
|
|
|
|
// Determine the VM's OS description
|
|
GuestOSVO guestOS = _guestOsDao.findById(vm.getGuestOSId());
|
|
if (guestOS == null) {
|
|
throw new CloudRuntimeException("Guest OS is not set");
|
|
}
|
|
|
|
//VMInstanceVO vm = _vmDao.findById(vm.getId());
|
|
VirtualMachineProfile vmProfile = new VirtualMachineProfile(vm, serviceOffering, guestOS.getDisplayName(), template.getHypervisorType());
|
|
|
|
Transaction txn = Transaction.currentTxn();
|
|
txn.start();
|
|
vm.setDataCenterId(plan.getDataCenterId());
|
|
_vmDao.update(vm.getId(), vm);
|
|
|
|
List<NicProfile> nics = _networkMgr.allocate(vmProfile, networks);
|
|
vmProfile.setNics(nics);
|
|
|
|
if (dataDiskOfferings == null) {
|
|
dataDiskOfferings = new ArrayList<Pair<DiskOfferingVO, Long>>(0);
|
|
}
|
|
|
|
List<DiskProfile> disks = new ArrayList<DiskProfile>(dataDiskOfferings.size() + 1);
|
|
if (template.getFormat() == ImageFormat.ISO) {
|
|
disks.add(_storageMgr.allocateRawVolume(VolumeType.ROOT, "ROOT-" + vm.getId(), rootDiskOffering.first(), rootDiskOffering.second(), vm, owner));
|
|
} else {
|
|
disks.add(_storageMgr.allocateTemplatedVolume(VolumeType.ROOT, "ROOT-" + vm.getId(), rootDiskOffering.first(), template, vm, owner));
|
|
}
|
|
for (Pair<DiskOfferingVO, Long> offering : dataDiskOfferings) {
|
|
disks.add(_storageMgr.allocateRawVolume(VolumeType.DATADISK, "DATA-" + vm.getId(), offering.first(), offering.second(), vm, owner));
|
|
}
|
|
vmProfile.setDisks(disks);
|
|
|
|
_vmDao.updateIf(vm, Event.OperationSucceeded, null);
|
|
txn.commit();
|
|
if (s_logger.isDebugEnabled()) {
|
|
s_logger.debug("Allocation completed for VM: " + vm);
|
|
}
|
|
|
|
return vmProfile;
|
|
}
|
|
|
|
@Override
|
|
public <T extends VMInstanceVO> VirtualMachineProfile allocate(T vm,
|
|
VMTemplateVO template,
|
|
ServiceOfferingVO serviceOffering,
|
|
Long rootSize,
|
|
Pair<DiskOfferingVO, Long> dataDiskOffering,
|
|
List<Pair<NetworkConfigurationVO, NicProfile>> networks,
|
|
DeploymentPlan plan,
|
|
AccountVO owner) throws InsufficientCapacityException {
|
|
List<Pair<DiskOfferingVO, Long>> diskOfferings = new ArrayList<Pair<DiskOfferingVO, Long>>(1);
|
|
if (dataDiskOffering != null) {
|
|
diskOfferings.add(dataDiskOffering);
|
|
}
|
|
return allocate(vm, template, serviceOffering, new Pair<DiskOfferingVO, Long>(serviceOffering, rootSize), diskOfferings, networks, plan, owner);
|
|
}
|
|
|
|
@Override
|
|
public <T extends VMInstanceVO> VirtualMachineProfile allocate(T vm,
|
|
VMTemplateVO template,
|
|
ServiceOfferingVO serviceOffering,
|
|
List<Pair<NetworkConfigurationVO, NicProfile>> networks,
|
|
DeploymentPlan plan,
|
|
AccountVO owner) throws InsufficientCapacityException {
|
|
return allocate(vm, template, serviceOffering, new Pair<DiskOfferingVO, Long>(serviceOffering, null), null, networks, plan, owner);
|
|
}
|
|
|
|
@Override
|
|
public void destroy() {
|
|
// TODO Auto-generated method stub
|
|
|
|
}
|
|
|
|
@Override
|
|
public boolean start() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean stop() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean configure(String name, Map<String, Object> xmlParams) throws ConfigurationException {
|
|
_name = name;
|
|
|
|
ComponentLocator locator = ComponentLocator.getCurrentLocator();
|
|
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
|
|
Map<String, String> params = configDao.getConfiguration(xmlParams);
|
|
|
|
_planners = locator.getAdapters(DeploymentPlanner.class);
|
|
|
|
_retry = NumbersUtil.parseInt(params.get(Config.StartRetry.key()), 2);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return _name;
|
|
}
|
|
|
|
protected MauriceMoss() {
|
|
}
|
|
|
|
@Override
|
|
public <T extends VMInstanceVO> T start(T vm, DeploymentPlan plan, VirtualMachineChecker checker) throws InsufficientCapacityException, ConcurrentOperationException {
|
|
if (s_logger.isDebugEnabled()) {
|
|
s_logger.debug("Creating actual resources for VM " + vm);
|
|
}
|
|
|
|
Journal journal = new Journal.LogJournal("Creating " + vm, s_logger);
|
|
|
|
ServiceOffering offering = _offeringDao.findById(vm.getServiceOfferingId());
|
|
VMTemplateVO template = _templateDao.findById(vm.getTemplateId());
|
|
|
|
BootloaderType bt = BootloaderType.PyGrub;
|
|
if (template.getFormat() == Storage.ImageFormat.ISO || template.isRequiresHvm()) {
|
|
bt = BootloaderType.HVM;
|
|
}
|
|
|
|
// Determine the VM's OS description
|
|
GuestOSVO guestOS = _guestOsDao.findById(vm.getGuestOSId());
|
|
if (guestOS == null) {
|
|
throw new CloudRuntimeException("Guest OS is not set");
|
|
}
|
|
VirtualMachineProfile vmProfile = new VirtualMachineProfile(vm, offering, guestOS.getDisplayName(), template.getHypervisorType());
|
|
_vmDao.updateIf(vm, Event.StartRequested, null);
|
|
|
|
Set<DeployDestination> avoids = new HashSet<DeployDestination>();
|
|
int retry = _retry;
|
|
while (retry-- != 0) { // It's != so that it can match -1.
|
|
DeployDestination dest = null;
|
|
for (DeploymentPlanner dispatcher : _planners) {
|
|
dest = dispatcher.plan(vmProfile, plan, avoids);
|
|
if (dest != null) {
|
|
avoids.add(dest);
|
|
journal.record("Deployment found ", vmProfile, dest);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dest == null) {
|
|
throw new CloudRuntimeException("Unable to create a deployment for " + vmProfile);
|
|
}
|
|
|
|
vm.setDataCenterId(dest.getDataCenter().getId());
|
|
vm.setPodId(dest.getPod().getId());
|
|
_vmDao.updateIf(vm, Event.OperationRetry, dest.getHost().getId());
|
|
|
|
VirtualMachineTO vmTO = new VirtualMachineTO(vmProfile, bt);
|
|
VolumeTO[] volumes = null;
|
|
try {
|
|
volumes = _storageMgr.prepare(vmProfile, dest);
|
|
} catch (ConcurrentOperationException e) {
|
|
throw e;
|
|
} catch (StorageUnavailableException e) {
|
|
s_logger.warn("Unable to contact storage.", e);
|
|
continue;
|
|
}
|
|
NicTO[] nics = _networkMgr.prepare(vmProfile, dest);
|
|
|
|
vmTO.setNics(nics);
|
|
vmTO.setDisks(volumes);
|
|
|
|
if (checker != null) {
|
|
checker.finalizeDeployment(vmTO, vmProfile, dest);
|
|
}
|
|
|
|
Start2Command cmd = new Start2Command(vmTO);
|
|
try {
|
|
Start2Answer answer = (Start2Answer)_agentMgr.send(dest.getHost().getId(), cmd);
|
|
if (answer.getResult()) {
|
|
if (!_vmDao.updateIf(vm, Event.OperationSucceeded, dest.getHost().getId())) {
|
|
throw new CloudRuntimeException("Unable to transition to a new state.");
|
|
}
|
|
return vm;
|
|
}
|
|
s_logger.info("Unable to start VM on " + dest.getHost() + " due to " + answer.getDetails());
|
|
} catch (AgentUnavailableException e) {
|
|
s_logger.debug("Unable to send the start command to host " + dest.getHost());
|
|
continue;
|
|
} catch (OperationTimedoutException e) {
|
|
s_logger.debug("Unable to send the start command to host " + dest.getHost());
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (s_logger.isDebugEnabled()) {
|
|
s_logger.debug("Creation complete for VM " + vmProfile);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public <T extends VMInstanceVO> T stop(T vm) throws AgentUnavailableException {
|
|
// TODO Auto-generated method stub
|
|
return null;
|
|
}
|
|
|
|
}
|