cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ahu...@apache.org
Subject [3/8] Complete the move of the virtualmachinemanager to cloud-engine
Date Thu, 13 Jun 2013 23:34:36 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3ef77bc8/server/src/com/cloud/vm/VirtualMachineManagerImpl.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/vm/VirtualMachineManagerImpl.java b/server/src/com/cloud/vm/VirtualMachineManagerImpl.java
deleted file mode 100755
index 2a8d5c3..0000000
--- a/server/src/com/cloud/vm/VirtualMachineManagerImpl.java
+++ /dev/null
@@ -1,3560 +0,0 @@
-// 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.net.URI;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
-import javax.ejb.Local;
-import javax.inject.Inject;
-import javax.naming.ConfigurationException;
-
-import org.apache.log4j.Logger;
-
-import org.apache.cloudstack.affinity.dao.AffinityGroupVMMapDao;
-import org.apache.cloudstack.config.ConfigRepo;
-import org.apache.cloudstack.config.ConfigValue;
-import org.apache.cloudstack.context.CallContext;
-import org.apache.cloudstack.engine.config.Configs;
-import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
-import org.apache.cloudstack.engine.subsystem.api.storage.StoragePoolAllocator;
-import org.apache.cloudstack.framework.jobs.AsyncJobConstants;
-import org.apache.cloudstack.framework.jobs.AsyncJobManager;
-import org.apache.cloudstack.framework.messagebus.MessageBus;
-import org.apache.cloudstack.framework.messagebus.MessageDispatcher;
-import org.apache.cloudstack.framework.messagebus.MessageHandler;
-import org.apache.cloudstack.messagebus.TopicConstants;
-import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
-import org.apache.cloudstack.vm.jobs.VmWorkJobDao;
-import org.apache.cloudstack.vm.jobs.VmWorkJobVO;
-import org.apache.cloudstack.vm.jobs.VmWorkJobVO.Step;
-
-import com.cloud.agent.AgentManager;
-import com.cloud.agent.AgentManager.OnError;
-import com.cloud.agent.Listener;
-import com.cloud.agent.api.AgentControlAnswer;
-import com.cloud.agent.api.AgentControlCommand;
-import com.cloud.agent.api.Answer;
-import com.cloud.agent.api.CheckVirtualMachineAnswer;
-import com.cloud.agent.api.CheckVirtualMachineCommand;
-import com.cloud.agent.api.ClusterSyncAnswer;
-import com.cloud.agent.api.Command;
-import com.cloud.agent.api.PingRoutingCommand;
-import com.cloud.agent.api.PlugNicAnswer;
-import com.cloud.agent.api.PlugNicCommand;
-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.StopAnswer;
-import com.cloud.agent.api.StopCommand;
-import com.cloud.agent.api.UnPlugNicAnswer;
-import com.cloud.agent.api.UnPlugNicCommand;
-import com.cloud.agent.api.to.NicTO;
-import com.cloud.agent.api.to.VirtualMachineTO;
-import com.cloud.agent.manager.Commands;
-import com.cloud.agent.manager.allocator.HostAllocator;
-import com.cloud.alert.AlertManager;
-import com.cloud.api.ApiSerializerHelper;
-import com.cloud.async.AsyncJobExecutionContext;
-import com.cloud.configuration.ConfigurationManager;
-import com.cloud.configuration.dao.ConfigurationDao;
-import com.cloud.dao.EntityManager;
-import com.cloud.dc.ClusterDetailsDao;
-import com.cloud.dc.ClusterDetailsVO;
-import com.cloud.dc.ClusterVO;
-import com.cloud.dc.DataCenter;
-import com.cloud.dc.DataCenterVO;
-import com.cloud.dc.HostPodVO;
-import com.cloud.deploy.DataCenterDeployment;
-import com.cloud.deploy.DeployDestination;
-import com.cloud.deploy.DeploymentPlan;
-import com.cloud.deploy.DeploymentPlanner;
-import com.cloud.deploy.DeploymentPlanner.ExcludeList;
-import com.cloud.deploy.DeploymentPlanningManager;
-import com.cloud.event.EventTypes;
-import com.cloud.event.UsageEventUtils;
-import com.cloud.exception.AffinityConflictException;
-import com.cloud.exception.AgentUnavailableException;
-import com.cloud.exception.ConcurrentOperationException;
-import com.cloud.exception.ConnectionException;
-import com.cloud.exception.InsufficientAddressCapacityException;
-import com.cloud.exception.InsufficientCapacityException;
-import com.cloud.exception.InsufficientServerCapacityException;
-import com.cloud.exception.InsufficientVirtualNetworkCapcityException;
-import com.cloud.exception.InvalidParameterValueException;
-import com.cloud.exception.ManagementServerException;
-import com.cloud.exception.OperationTimedoutException;
-import com.cloud.exception.ResourceUnavailableException;
-import com.cloud.exception.VirtualMachineMigrationException;
-import com.cloud.ha.HighAvailabilityManager;
-import com.cloud.ha.HighAvailabilityManager.WorkType;
-import com.cloud.host.Host;
-import com.cloud.host.HostVO;
-import com.cloud.host.Status;
-import com.cloud.host.dao.HostDao;
-import com.cloud.hypervisor.Hypervisor.HypervisorType;
-import com.cloud.hypervisor.HypervisorGuru;
-import com.cloud.hypervisor.HypervisorGuruManager;
-import com.cloud.network.Network;
-import com.cloud.network.NetworkManager;
-import com.cloud.network.NetworkModel;
-import com.cloud.network.dao.NetworkVO;
-import com.cloud.network.rules.RulesManager;
-import com.cloud.offering.ServiceOffering;
-import com.cloud.org.Cluster;
-import com.cloud.resource.ResourceManager;
-import com.cloud.service.ServiceOfferingVO;
-import com.cloud.storage.DiskOfferingVO;
-import com.cloud.storage.Storage.ImageFormat;
-import com.cloud.storage.StorageManager;
-import com.cloud.storage.StoragePool;
-import com.cloud.storage.VMTemplateVO;
-import com.cloud.storage.Volume;
-import com.cloud.storage.Volume.Type;
-import com.cloud.storage.VolumeManager;
-import com.cloud.storage.VolumeVO;
-import com.cloud.storage.dao.StoragePoolHostDao;
-import com.cloud.storage.dao.VolumeDao;
-import com.cloud.user.Account;
-import com.cloud.user.AccountManager;
-import com.cloud.user.User;
-import com.cloud.utils.DateUtil;
-import com.cloud.utils.Journal;
-import com.cloud.utils.Pair;
-import com.cloud.utils.Predicate;
-import com.cloud.utils.Ternary;
-import com.cloud.utils.component.ManagerBase;
-import com.cloud.utils.concurrency.NamedThreadFactory;
-import com.cloud.utils.db.DB;
-import com.cloud.utils.db.GlobalLock;
-import com.cloud.utils.db.SearchBuilder;
-import com.cloud.utils.db.SearchCriteria;
-import com.cloud.utils.db.Transaction;
-import com.cloud.utils.exception.CloudRuntimeException;
-import com.cloud.utils.exception.ExecutionException;
-import com.cloud.utils.fsm.NoTransitionException;
-import com.cloud.utils.fsm.StateMachine2;
-import com.cloud.vm.VirtualMachine.Event;
-import com.cloud.vm.VirtualMachine.PowerState;
-import com.cloud.vm.VirtualMachine.State;
-import com.cloud.vm.dao.NicDao;
-import com.cloud.vm.dao.UserVmDetailsDao;
-import com.cloud.vm.dao.VMInstanceDao;
-import com.cloud.vm.snapshot.VMSnapshotManager;
-
-@Local(value = VirtualMachineManager.class)
-public class VirtualMachineManagerImpl extends ManagerBase implements VirtualMachineManager, Listener {
-    private static final Logger s_logger = Logger.getLogger(VirtualMachineManagerImpl.class);
-
-    @Inject
-    protected EntityManager _entityMgr;
-    @Inject
-    ConfigRepo _configRepo;
-    @Inject
-    protected StorageManager _storageMgr;
-    @Inject
-    DataStoreManager _dataStoreMgr;
-    @Inject
-    protected NetworkManager _networkMgr;
-    @Inject
-    protected NetworkModel _networkModel;
-    @Inject
-    protected AgentManager _agentMgr;
-    @Inject
-    protected VMInstanceDao _vmDao;
-/*
-    @Inject
-    protected ItWorkDao _workDao;
-*/
-    
-    @Inject
-    protected NicDao _nicsDao;
-    @Inject
-    protected AccountManager _accountMgr;
-    @Inject
-    protected HostDao _hostDao;
-    @Inject
-    protected AlertManager _alertMgr;
-    @Inject
-    protected VolumeDao _volsDao;
-    @Inject
-    protected ConfigurationManager _configMgr;
-    @Inject
-    protected HighAvailabilityManager _haMgr;
-    @Inject
-    protected HypervisorGuruManager _hvGuruMgr;
-    @Inject
-    protected StoragePoolHostDao _poolHostDao;
-    @Inject
-    protected RulesManager rulesMgr;
-    @Inject
-    protected AffinityGroupVMMapDao _affinityGroupVMMapDao;
-
-    @Inject
-    protected List<DeploymentPlanner> _planners;
-
-    protected List<HostAllocator> _hostAllocators;
-
-    public List<HostAllocator> getHostAllocators() {
-        return _hostAllocators;
-    }
-
-    public void setHostAllocators(List<HostAllocator> hostAllocators) {
-        _hostAllocators = hostAllocators;
-    }
-
-	@Inject
-    protected List<StoragePoolAllocator> _storagePoolAllocators;
-
-    @Inject
-    protected ResourceManager _resourceMgr;
-    
-    @Inject
-    protected VMSnapshotManager _vmSnapshotMgr = null;
-    @Inject
-    protected ClusterDetailsDao  _clusterDetailsDao;
-    @Inject
-    protected UserVmDetailsDao _uservmDetailsDao;
-    
-    @Inject
-    protected VMInstanceDao _instanceDao;
-
-    @Inject
-    protected ConfigurationDao _configDao;
-    @Inject
-    VolumeManager _volumeMgr;
-    
-    @Inject protected MessageBus _messageBus;
-    @Inject protected VirtualMachinePowerStateSync _syncMgr;
-    @Inject protected VmWorkJobDao _workJobDao;
-    @Inject protected AsyncJobManager _jobMgr;
-    @Inject
-    DeploymentPlanningManager _dpMgr;
-
-    Map<VirtualMachine.Type, VirtualMachineGuru> _vmGurus = new HashMap<VirtualMachine.Type, VirtualMachineGuru>();
-    protected StateMachine2<State, VirtualMachine.Event, VirtualMachine> _stateMachine;
-
-    ScheduledExecutorService _executor = null;
-
-    protected ConfigValue<Integer> _retry;
-    protected ConfigValue<Integer> _cancelWait;
-    protected ConfigValue<Long> _cleanupWait;
-    protected ConfigValue<Long> _cleanupInterval;
-    protected ConfigValue<Long> _opWaitInterval;
-    protected ConfigValue<Integer> _lockStateRetry;
-    protected ConfigValue<Integer> _operationTimeout;
-    protected ConfigValue<Boolean> _forceStop;
-    protected long _nodeId;
-
-    SearchBuilder<VolumeVO> RootVolumeSearch;
-
-    @Override
-    public void registerGuru(VirtualMachine.Type type, VirtualMachineGuru guru) {
-        synchronized (_vmGurus) {
-            _vmGurus.put(type, guru);
-        }
-    }
-    
-    private VirtualMachineGuru getVmGuru(VirtualMachine vm) {
-        return _vmGurus.get(vm.getType());
-    }
-
-    @Override
-    @DB
-    public boolean allocate(String vmInstanceName, VMTemplateVO template, ServiceOfferingVO serviceOffering, Pair<? extends DiskOfferingVO, Long> rootDiskOffering,
-            List<Pair<DiskOfferingVO, Long>> dataDiskOfferings, List<Pair<NetworkVO, NicProfile>> networks, Map<VirtualMachineProfile.Param, Object> params, DeploymentPlan plan,
-            HypervisorType hyperType, Account owner) {
-        assert (plan.getClusterId() == null && plan.getPoolId() == null) : "We currently don't support cluster and pool preset yet";
-
-        VMInstanceVO vm = _vmDao.findVMByInstanceName(vmInstanceName);
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Allocating entries for VM: " + vm);
-        }
-
-        VirtualMachineProfileImpl vmProfile = new VirtualMachineProfileImpl(vm, template, serviceOffering, owner, params);
-
-        vm.setDataCenterId(plan.getDataCenterId());
-        if (plan.getPodId() != null) {
-            vm.setPodId(plan.getPodId());
-        }
-
-        Transaction txn = Transaction.currentTxn();
-        txn.start();
-        _vmDao.update(vm.getId(), vm);
-
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Allocating nics for " + vm);
-        }
-
-        try {
-            _networkMgr.allocate(vmProfile, networks);
-        } catch (ConcurrentOperationException e) {
-            throw new CloudRuntimeException("Concurrent operation while trying to allocate resources for the VM", e);
-        } catch (InsufficientCapacityException e) {
-            throw new CloudRuntimeException("Insufficient Capacity to create a vm ", e);
-        }
-
-        if (dataDiskOfferings == null) {
-            dataDiskOfferings = new ArrayList<Pair<DiskOfferingVO, Long>>(0);
-        }
-
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Allocating disks for " + vm);
-        }
-
-        if (template.getFormat() == ImageFormat.ISO) {
-            _volumeMgr.allocateRawVolume(Type.ROOT, "ROOT-" + vm.getId(), rootDiskOffering.first(), rootDiskOffering.second(), vm, owner);
-        } else if (template.getFormat() == ImageFormat.BAREMETAL) {
-            // Do nothing
-        } else {
-            _volumeMgr.allocateTemplatedVolume(Type.ROOT, "ROOT-" + vm.getId(), rootDiskOffering.first(), template, vm, owner);
-        }
-
-        for (Pair<DiskOfferingVO, Long> offering : dataDiskOfferings) {
-            _volumeMgr.allocateRawVolume(Type.DATADISK, "DATA-" + vm.getId(), offering.first(), offering.second(), vm, owner);
-        }
-
-        txn.commit();
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Allocation completed for VM: " + vm);
-        }
-
-        return true;
-    }
-
-    @Override
-    public boolean allocate(String vmInstanceName, VMTemplateVO template, ServiceOfferingVO serviceOffering, List<Pair<NetworkVO, NicProfile>> networks,
-            DeploymentPlan plan, HypervisorType hyperType, Account owner) {
-        return allocate(vmInstanceName, template, serviceOffering, new Pair<DiskOfferingVO, Long>(serviceOffering, null), null, networks, null, plan, hyperType, owner);
-    }
-
-    @Override
-    public void expunge(String vmUuid) {
-        try {
-            advanceExpunge(vmUuid);
-        } catch (OperationTimedoutException e) {
-            throw new CloudRuntimeException("Operation timed out", e);
-        } catch (ConcurrentOperationException e) {
-            throw new CloudRuntimeException("Concurrent operation ", e);
-        } catch (ResourceUnavailableException e) {
-            throw new CloudRuntimeException("Resource is unavailable ", e);
-        }
-    }
-
-    @Override
-    public void advanceExpunge(String vmUuid) throws ResourceUnavailableException, OperationTimedoutException,
-            ConcurrentOperationException {
-        VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-        if (vm == null || vm.getRemoved() != null) {
-            if (s_logger.isDebugEnabled()) {
-                s_logger.debug("Unable to find vm or vm is destroyed: " + vm);
-            }
-            return;
-        }
-
-        advanceStop(vmUuid, false);
-
-        vm = _vmDao.findByUuid(vmUuid);
-        try {
-            if (!stateTransitTo(vm, VirtualMachine.Event.ExpungeOperation, vm.getHostId())) {
-                throw new CloudRuntimeException("Unable to detroy the VM because it is not in the correct state: " + vm);
-            }
-        } catch (NoTransitionException e) {
-            throw new CloudRuntimeException("Unable to destroy the vm because it is not in the correct state: " + vm);
-        }
-
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Destroying vm " + vm);
-        }
-
-        VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
-        s_logger.debug("Cleaning up NICS");
-        _networkMgr.cleanupNics(profile);
-        // Clean up volumes based on the vm's instance id
-        _volumeMgr.cleanupVolumes(vm.getId());
-
-        VirtualMachineGuru guru = getVmGuru(vm);
-        guru.finalizeExpunge(vm);
-        //remove the overcommit detials from the uservm details
-        _uservmDetailsDao.deleteDetails(vm.getId());
-
-        // send hypervisor-dependent commands before removing
-        HypervisorGuru hvGuru = _hvGuruMgr.getGuru(vm.getHypervisorType());
-        List<Command> finalizeExpungeCommands = hvGuru.finalizeExpunge(vm);
-        if(finalizeExpungeCommands != null && finalizeExpungeCommands.size() > 0){
-            Long hostId = vm.getHostId() != null ? vm.getHostId() : vm.getLastHostId();
-            if(hostId != null){
-                Commands cmds = new Commands(OnError.Stop);
-                for (Command command : finalizeExpungeCommands) {
-                    cmds.addCommand(command);
-                }
-                _agentMgr.send(hostId, cmds);
-                if(!cmds.isSuccessful()){
-                    for (Answer answer : cmds.getAnswers()){
-                        if(answer != null && !answer.getResult()){
-                            s_logger.warn("Failed to expunge vm due to: " + answer.getDetails());
-                            break;
-                        }
-                    }
-                    throw new CloudRuntimeException("Failed the expunge the vm on the hypervisor");
-                }
-            }
-        }
-
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Expunged " + vm);
-        }
-        
-        _vmDao.remove(vm.getId());
-    }
-    
-    
-
-    @Override
-    public boolean start() {
-        _executor.scheduleAtFixedRate(new CleanupTask(), _cleanupInterval.value(), _cleanupInterval.value(), TimeUnit.SECONDS);
-        cancelWorkItems(_nodeId);
-        
-        return true;
-    }
- 
-    @Override
-    public boolean stop() {
-        return true;
-    }
-
-    @Override
-    public boolean configure(String name, Map<String, Object> xmlParams) throws ConfigurationException {
-        Map<String, String> params = _configDao.getConfiguration(xmlParams);
-
-        _retry = _configRepo.get(Configs.StartRetry);
-
-        _cancelWait = _configRepo.get(Configs.VmOpCancelInterval);
-        _cleanupWait = _configRepo.get(Configs.VmOpCleanupWait);
-        _cleanupInterval = _configRepo.get(Configs.VmOpCleanupInterval).setMultiplier(1000);
-        _opWaitInterval = _configRepo.get(Configs.VmOpWaitInterval).setMultiplier(1000);
-        _lockStateRetry = _configRepo.get(Configs.VmOpLockStateRetry);
-        _operationTimeout = _configRepo.get(Configs.Wait).setMultiplier(2);
-        _forceStop = _configRepo.get(Configs.VmDestroyForcestop);
-
-        ReservationContextImpl.setComponents(_entityMgr);
-        VirtualMachineProfileImpl.setComponents(_entityMgr);
-
-        _executor = Executors.newScheduledThreadPool(1, new NamedThreadFactory("Vm-Operations-Cleanup"));
-
-        _agentMgr.registerForHostEvents(this, true, true, true);
-        
-        RootVolumeSearch = _entityMgr.createSearchBuilder(VolumeVO.class);
-        VolumeVO rvsEntity = RootVolumeSearch.entity();
-        RootVolumeSearch.and(rvsEntity.getVolumeType(), SearchCriteria.Op.EQ).values(Volume.Type.ROOT)
-                .and(rvsEntity.getState(), SearchCriteria.Op.EQ).values(Volume.State.Ready)
-                .and(rvsEntity.getInstanceId(), SearchCriteria.Op.EQ, "instance")
-                .and(rvsEntity.getDeviceId(), SearchCriteria.Op.EQ).values(0)
-                .done();
-
-        
-        _messageBus.subscribe(TopicConstants.VM_POWER_STATE, MessageDispatcher.getDispatcher(this));
-      
-        return true;
-    }
-
-    protected VirtualMachineManagerImpl() {
-        setStateMachine();
-    }
-
-    @Override
-    public void start(String vmUuid, Map<VirtualMachineProfile.Param, Object> params) {
-        start(vmUuid, params, null);
-    }
-
-    @Override
-    public void start(String vmUuid, Map<VirtualMachineProfile.Param, Object> params, DeploymentPlan planToDeploy) {
-        try {
-            advanceStart(vmUuid, params, planToDeploy);
-        } catch (ConcurrentOperationException e) {
-            throw new CloudRuntimeException(e).add(VirtualMachine.class, vmUuid);
-        } catch (InsufficientCapacityException e) {
-            throw new CloudRuntimeException(e).add(VirtualMachine.class, vmUuid);
-        } catch (ResourceUnavailableException e) {
-            throw new CloudRuntimeException(e).add(VirtualMachine.class, vmUuid);
-        }
-    }
-
-    /*
-        protected boolean checkWorkItems(VMInstanceVO vm, State state) throws ConcurrentOperationException {
-            while (true) {
-                VmWorkJobVO vo = _workDao.findByOutstandingWork(vm.getId(), state);
-                if (vo == null) {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("Unable to find work for VM: " + vm + " and state: " + state);
-                    }
-                    return true;
-                }
-
-                if (vo.getStep() == Step.Done) {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("Work for " + vm + " is " + vo.getStep());
-                    }
-                    return true;
-                }
-
-                if (vo.getSecondsTaskIsInactive() > _cancelWait) {
-                    s_logger.warn("The task item for vm " + vm + " has been inactive for " + vo.getSecondsTaskIsInactive());
-                    return false;
-                }
-
-                try {
-                    Thread.sleep(_opWaitInterval);
-                } catch (InterruptedException e) {
-                    s_logger.info("Waiting for " + vm + " but is interrupted");
-                    throw new ConcurrentOperationException("Waiting for " + vm + " but is interrupted");
-                }
-                s_logger.debug("Waiting some more to make sure there's no activity on " + vm);
-            }
-        }
-    */
-    
-    /*
-        @DB
-        protected VirtualMachineernary<T, ReservationContext, VmWorkJobVO> changeToStartState(VirtualMachineGuru<T> vmGuru, String vmUuid, User caller, Account account)
-                throws ConcurrentOperationException {
-            long vmId = vm.getId();
-
-            VmWorkJobVO work = new VmWorkJobVO(UUID.randomUUID().toString(), _nodeId, State.Starting, vm.getType(), vm.getId());
-            int retry = _lockStateRetry;
-            while (retry-- != 0) {
-                Transaction txn = Transaction.currentTxn();
-                Ternary<T, ReservationContext, VmWorkJobVO> result = null;
-                txn.start();
-                try {
-                    Journal journal = new Journal.LogJournal("Creating " + vm, s_logger);
-                    work = _workDao.persist(work);
-                    ReservationContextImpl context = new ReservationContextImpl(work.getId(), journal, caller, account);
-
-                    if (stateTransitTo(vm, Event.StartRequested, null, work.getId())) {
-                        if (s_logger.isDebugEnabled()) {
-                            s_logger.debug("Successfully transitioned to start state for " + vm + " reservation id = " + work.getId());
-                        }
-                        result = new Ternary<T, ReservationContext, VmWorkJobVO>(vmGuru.findById(vmId), context, work);
-                        txn.commit();
-                        return result;
-                    }
-                } catch (NoTransitionException e) {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("Unable to transition into Starting state due to " + e.getMessage());
-                    }
-                } finally {
-                    if (result == null) {
-                        txn.rollback();
-                    }
-                }
-
-                VMInstanceVO instance = _vmDao.findById(vmId);
-                if (instance == null) {
-                    throw new ConcurrentOperationException("Unable to acquire lock on " + vm);
-                }
-
-                if (s_logger.isDebugEnabled()) {
-                    s_logger.debug("Determining why we're unable to update the state to Starting for " + instance + ".  Retry=" + retry);
-                }
-
-                State state = instance.getState();
-                if (state == State.Running) {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("VM is already started: " + vm);
-                    }
-                    return null;
-                }
-
-                if (state.isTransitional()) {
-                    if (!checkWorkItems(vm, state)) {
-                        throw new ConcurrentOperationException("There are concurrent operations on " + vm);
-                    } else {
-                        continue;
-                    }
-                }
-
-                if (state != State.Stopped) {
-                    s_logger.debug("VM " + vm + " is not in a state to be started: " + state);
-                    return null;
-                }
-            }
-
-            throw new ConcurrentOperationException("Unable to change the state of " + vm);
-        }
-    */
-
-    @DB
-    protected Ternary<VMInstanceVO, ReservationContext, VmWorkJobVO> changeToStartState(VirtualMachineGuru vmGuru, VMInstanceVO vm, User caller, Account account)
-        throws ConcurrentOperationException {
-    	
-        Ternary<VMInstanceVO, ReservationContext, VmWorkJobVO> result = null;
-        Transaction txn = Transaction.currentTxn();
-        txn.start();
-        try {
-	        VmWorkJobVO work = _workJobDao.findById(AsyncJobExecutionContext.getCurrentExecutionContext().getJob().getId());
-	        
-	        Journal journal = new Journal.LogJournal("Creating " + vm, s_logger);
-	        ReservationContextImpl context = new ReservationContextImpl(work.getUuid(), journal, caller, account);
-	        if (stateTransitTo(vm, Event.StartRequested, null, work.getUuid())) {
-	            if (s_logger.isDebugEnabled()) {
-	                s_logger.debug("Successfully transitioned to start state for " + vm + " reservation id = " + work.getId());
-	            }
-                result = new Ternary<VMInstanceVO, ReservationContext, VmWorkJobVO>(_vmDao.findById(vm.getId()), context, work);
-	            txn.commit();
-	            return result;
-	        }
-        } catch (NoTransitionException e) {
-            s_logger.warn("Unable to transition into Starting state due to " + e.getMessage());
-        } finally {
-        	if(result == null)
-        		txn.rollback();
-        }
-        
-        throw new ConcurrentOperationException("Unable to change the state of " + vm);
-    }
-    
-    protected boolean changeState(VMInstanceVO vm, Event event, Long hostId, VmWorkJobVO work, Step step) throws NoTransitionException {
-        // FIXME: We should do this better.
-        VmWorkJobVO.Step previousStep = work.getStep();
-        
-        boolean result = false;
-        try {
-            result = stateTransitTo(vm, event, hostId);
-            return result;
-        } finally {
-            if (!result) {
-            	work.setStep(previousStep);
-            	_workJobDao.update(work.getId(), work);
-            }
-        }
-    }
-    
-    protected boolean areAffinityGroupsAssociated(VirtualMachineProfile vmProfile) {
-        VirtualMachine vm = vmProfile.getVirtualMachine();
-        long vmGroupCount = _affinityGroupVMMapDao.countAffinityGroupsForVm(vm.getId());
-
-        if (vmGroupCount > 0) {
-            return true;
-        }
-        return false;
-    }
-
-    @Override
-    @DB
-    public void advanceStart(String vmUuid, Map<VirtualMachineProfile.Param, Object> params, DeploymentPlan planToDeploy)
-        throws InsufficientCapacityException, ConcurrentOperationException, ResourceUnavailableException {
-        CallContext context = CallContext.current();
-        User callingUser = context.getCallingUser();
-        Account callingAccount = context.getCallingAccount();
-
-        final VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-    	
-    	VmWorkJobVO workJob = null;
-    	Transaction txn = Transaction.currentTxn();
-    	try {
-        	txn.start();
-        	
-        	_vmDao.lockRow(vm.getId(), true);
-        	
-        	List<VmWorkJobVO> pendingWorkJobs = _workJobDao.listPendingWorkJobs(
-                    VirtualMachine.Type.Instance, vm.getId(), VmWorkJobDispatcher.Start);
-        	
-        	if(pendingWorkJobs != null && pendingWorkJobs.size() > 0) {
-        		assert(pendingWorkJobs.size() == 1);
-        		workJob = pendingWorkJobs.get(0);
-        	} else {
-                workJob = new VmWorkJobVO(context.getContextId());
-        	
-                workJob.setDispatcher(VmWorkJobDispatcher.VM_WORK_JOB_DISPATCHER);
-                workJob.setCmd(VmWorkJobDispatcher.Start);
-        		
-                workJob.setAccountId(callingAccount.getId());
-        		workJob.setUserId(callingUser.getId());
-        		workJob.setStep(VmWorkJobVO.Step.Starting);
-        		workJob.setVmType(vm.getType());
-        		workJob.setVmInstanceId(vm.getId());
-
-        		// save work context info (there are some duplications)
-        		VmWorkStart workInfo = new VmWorkStart();
-                workInfo.setAccountId(callingAccount.getId());
-        		workInfo.setUserId(callingUser.getId());
-        		workInfo.setVmId(vm.getId());
-        		workInfo.setPlan(planToDeploy);
-        		workInfo.setParams(params);
-        		workJob.setCmdInfo(ApiSerializerHelper.toSerializedString(workInfo));
-        		
-                _jobMgr.submitAsyncJob(workJob, VmWorkJobDispatcher.VM_WORK_QUEUE, vm.getId());
-        	}
-    	
-        	txn.commit();
-    	} catch(Throwable e) {
-    		s_logger.error("Unexpected exception", e);
-            throw new ConcurrentOperationException("Unhandled exception, converted to ConcurrentOperationException", e);
-    	}
-
-    	final long jobId = workJob.getId();
-    	
-    	AsyncJobExecutionContext.getCurrentExecutionContext().joinJob(jobId);
-
-    	//
-    	// TODO : this will be replaced with fully-asynchronous way later so that we don't need
-    	// to wait here. The reason we do synchronous-wait here is that callers of advanceStart is expecting
-    	// synchronous semantics
-    	//
-    	//
-    	_jobMgr.waitAndCheck(
-    		new String[] { TopicConstants.VM_POWER_STATE, TopicConstants.JOB_STATE },
-    		3000L, 600000L, new Predicate() {
-
-				@Override
-				public boolean checkCondition() {
-					VMInstanceVO instance = _vmDao.findById(vm.getId());
-					if(instance.getPowerState() == VirtualMachine.PowerState.PowerOn)
-						return true;
-			
-					VmWorkJobVO workJob = _workJobDao.findById(jobId);
-					if(workJob.getStatus() != AsyncJobConstants.STATUS_IN_PROGRESS)
-						return true;
-					
-					return false;
-				}
-    		});
-    	AsyncJobExecutionContext.getCurrentExecutionContext().disjoinJob(jobId);
-    	
-        return;
-    }
-
-    private Pair<DeploymentPlan, DeployDestination> findDestination(VirtualMachineProfileImpl profile, DeploymentPlan planRequested, boolean reuseVolume,
-            ReservationContext reservation, AsyncJobExecutionContext job) throws InsufficientCapacityException, ResourceUnavailableException {
-        VirtualMachine vm = profile.getVirtualMachine();
-
-        DataCenterDeployment plan = null;
-        if (planRequested != null) {
-            plan = new DataCenterDeployment(planRequested);
-        } else {
-            plan = new DataCenterDeployment(vm.getDataCenterId(), vm.getPodIdToDeployIn(), null, null, null, null, reservation);
-        }
-        
-        job.log(s_logger, "Starting " + vm + " with requested " + plan);
-
-        boolean planChangedByVolume = false;
-        List<VolumeVO> vols = _entityMgr.search(VolumeVO.class, RootVolumeSearch.create("instance", vm.getId()));
-        
-        if (vols.size() > 0 && reuseVolume) {
-            // edit plan if this vm's ROOT volume is in READY state already
-            
-            VolumeVO vol = vols.get(0);
-            // make sure if the templateId is unchanged. If it is changed,
-            // let planner reassign pool for the volume even if it ready.
-            Long volTemplateId = vol.getTemplateId();
-            if (vol.isRecreatable() && volTemplateId != null &&
-                    vm.getTemplateId() != -1 && volTemplateId.longValue() != vm.getTemplateId()) {
-                job.log(s_logger, "Recreating" + vol + " of " + vm + " because its template has changed.");
-                plan.setPoolId(null);
-            } else {
-                StoragePool pool = (StoragePool)_dataStoreMgr.getPrimaryDataStore(vol.getPoolId());
-                Long rootVolPodId = pool.getPodId();
-                Long rootVolClusterId = pool.getClusterId();
-                Long clusterIdSpecified = plan.getClusterId();
-                if (clusterIdSpecified != null && rootVolClusterId != null &&
-                    clusterIdSpecified.longValue() != rootVolClusterId.longValue()) {
-                    job.log(s_logger, "Unable to satisfy the deployment plan because it is requesting cluster " + clusterIdSpecified + " but the root volume is in cluster " + rootVolClusterId);
-                    throw new ResourceUnavailableException("Unable to satisfy the deployment plan because it is requesting cluster " + clusterIdSpecified
-                            + " but the root volume is in cluster " + rootVolClusterId, Cluster.class, clusterIdSpecified);
-                }
-                plan.setPoolId(vol.getPoolId());
-                plan.setClusterId(rootVolClusterId);
-                plan.setPodId(rootVolPodId);
-                planChangedByVolume = true;
-                job.log(s_logger, "Deployment plan has been adjusted to " + plan);
-            }
-        }
-
-        DeployDestination dest = null;
-        try {
-            dest = _dpMgr.planDeployment(profile, plan, plan.getAvoids());
-        } catch (AffinityConflictException e2) {
-            throw new CloudRuntimeException("Unable to create deployment, affinity rules associted to the VM conflict", e2);
-        }
-
-        if (dest == null && planChangedByVolume) {
-            job.log(s_logger, "Unable to find a deploy destination using the adjusted deployment plan.  Replanning with ");
-            return findDestination(profile, planRequested, false, reservation, job);
-        }
-
-        if (dest == null) {
-            throw new InsufficientServerCapacityException("Unable to create a deployment for " + vm,
-                    DataCenter.class, plan.getDataCenterId(), areAffinityGroupsAssociated(profile));
-        }
-
-        plan.getAvoids().addHost(dest.getHost().getId());
-        job.log(s_logger, "Final deploy destination: " + dest);
-        return new Pair<DeploymentPlan, DeployDestination>(plan, dest);
-    }
-
-    /**
-     * orchestrateStart orchestrates the vm start process.  Note that this
-     * method is not in the interface.
-     * 
-     * @param vmUuid uuid for the vm
-     * @param params additional parameters passed
-     * @param planRequested deployment requested
-     * @throws InsufficientCapacityException when there's not enough infrastructure capacity to ensure successful start of a vm.
-     * @throws ConcurrentOperationException when there are multiple operations on the vm.
-     * @throws ResourceUnavailableException when the resource being used to start the vm is not available.
-     */
-    public void orchestrateStart(String vmUuid, Map<VirtualMachineProfile.Param, Object> params, DeploymentPlan planRequested)
-            throws InsufficientCapacityException, ConcurrentOperationException, ResourceUnavailableException {
-        CallContext context = CallContext.current();
-        User caller = context.getCallingUser();
-        Account account = context.getCallingAccount();
-        AsyncJobExecutionContext job = AsyncJobExecutionContext.getCurrentExecutionContext();
-
-        VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-        if (vm == null) {
-            throw new ConcurrentOperationException("Unable to find vm by " + vmUuid);
-        }
-
-        VirtualMachineGuru vmGuru = getVmGuru(vm);
-  
-        Ternary<VMInstanceVO, ReservationContext, VmWorkJobVO> start = changeToStartState(vmGuru, vm, caller, account);
-        assert(start != null);
-
-        ReservationContext reservation = start.second();
-        VmWorkJobVO work = start.third();
-
-        VMInstanceVO startedVm = null;
-        ServiceOfferingVO offering = _entityMgr.findById(ServiceOfferingVO.class, vm.getServiceOfferingId());
-        VMTemplateVO template = _entityMgr.findById(VMTemplateVO.class, vm.getTemplateId());
-
-        HypervisorGuru hvGuru = _hvGuruMgr.getGuru(vm.getHypervisorType());
-
-        boolean canRetry = true;
-        try {
-
-            boolean reuseVolume = true;
-            DeploymentPlan plan = planRequested;
-
-            int retry = _retry.value();
-            while (retry-- != 0) { // It's != so that it can match -1.
-
-                VirtualMachineProfileImpl vmProfile = new VirtualMachineProfileImpl(vm, template, offering, account, params);
-                Pair<DeploymentPlan, DeployDestination> result = findDestination(vmProfile, plan, reuseVolume, reservation, job);
-                plan = result.first();
-                DeployDestination dest = result.second();
-
-                long destHostId = dest.getHost().getId();
-                vm.setPodId(dest.getPod().getId());
-                Long cluster_id = dest.getCluster().getId();
-                ClusterDetailsVO cluster_detail_cpu = _clusterDetailsDao.findDetail(cluster_id, "cpuOvercommitRatio");
-                ClusterDetailsVO cluster_detail_ram = _clusterDetailsDao.findDetail(cluster_id, "memoryOvercommitRatio");
-                vmProfile.setCpuOvercommitRatio(Float.parseFloat(cluster_detail_cpu.getValue()));
-                vmProfile.setMemoryOvercommitRatio(Float.parseFloat(cluster_detail_ram.getValue()));
-
-                if (!changeState(vm, Event.OperationRetry, destHostId, work, Step.Prepare)) {
-                    throw new ConcurrentOperationException("Unable to update the state of the Virtual Machine");
-                }
-
-                try {
-                    _networkMgr.prepare(vmProfile, dest, reservation);
-                    _volumeMgr.prepare(vmProfile, dest);
-
-                    reuseVolume = true;
-
-                    Commands cmds = null;
-                    vmGuru.finalizeVirtualMachineProfile(vmProfile, dest, reservation);
-
-                    VirtualMachineTO vmTO = hvGuru.implement(vmProfile);
-
-                    cmds = new Commands(OnError.Stop);
-                    cmds.addCommand(new StartCommand(vmTO, dest.getHost()));
-
-                    vmGuru.finalizeDeployment(cmds, vmProfile, dest, reservation);
-
-                    work.setStep(VmWorkJobVO.Step.Starting);
-                    _workJobDao.update(work.getId(), work);
-
-                    _agentMgr.send(destHostId, cmds);
-
-                    work.setStep(VmWorkJobVO.Step.Started);
-                    _workJobDao.update(work.getId(), work);
-
-                    StartAnswer startAnswer = cmds.getAnswer(StartAnswer.class);
-                    if (startAnswer != null && startAnswer.getResult()) {
-                        String host_guid = startAnswer.getHost_guid();
-                        if( host_guid != null ) {
-                            HostVO finalHost = _resourceMgr.findHostByGuid(host_guid);
-                            if (finalHost == null ) {
-                                throw new CloudRuntimeException("Host Guid " + host_guid + " doesn't exist in DB, something wrong here");
-                            }
-                            destHostId = finalHost.getId();
-                        }
-                        if (vmGuru.finalizeStart(vmProfile, destHostId, cmds, reservation)) {
-                            if (!changeState(vm, Event.OperationSucceeded, destHostId, work, Step.Done)) {
-                                throw new ConcurrentOperationException("Unable to transition to a new state.");
-                            }
-                            startedVm = vm;
-                            if (s_logger.isDebugEnabled()) {
-                                s_logger.debug("Start completed for VM " + vm);
-                            }
-                            return;
-                        } else {
-                            if (s_logger.isDebugEnabled()) {
-                                s_logger.info("The guru did not like the answers so stopping " + vm);
-                            }
-
-                            StopCommand cmd = new StopCommand(vm);
-                            StopAnswer answer = (StopAnswer) _agentMgr.easySend(destHostId, cmd);
-                            if (answer == null || !answer.getResult()) {
-                                s_logger.warn("Unable to stop " + vm + " due to " + (answer != null ? answer.getDetails() : "no answers"));
-                                _haMgr.scheduleStop(vm, destHostId, WorkType.ForceStop);
-                                throw new ExecutionException("Unable to stop " + vm + " so we are unable to retry the start operation");
-                            }
-                            throw new ExecutionException("Unable to start " + vm + " due to error in finalizeStart, not retrying");
-                        }
-                    }
-                    s_logger.info("Unable to start VM on " + dest.getHost() + " due to " + (startAnswer == null ? " no start answer" : startAnswer.getDetails()));
-
-                } catch (OperationTimedoutException e) {
-                    s_logger.debug("Unable to send the start command to host " + dest.getHost());
-                    if (e.isActive()) {
-                        _haMgr.scheduleStop(vm, destHostId, WorkType.CheckStop);
-                    }
-                    canRetry = false;
-                    throw new AgentUnavailableException("Unable to start " + vm.getHostName(), destHostId, e);
-                } catch (ResourceUnavailableException e) {
-                    s_logger.info("Unable to contact resource.", e);
-                    if (!plan.getAvoids().add(e)) {
-                        if (e.getScope() == Volume.class || e.getScope() == Nic.class) {
-                            throw e;
-                        } else {
-                            s_logger.warn("unexpected ResourceUnavailableException : " + e.getScope().getName(), e);
-                            throw e;
-                        }
-                    }
-                } catch (InsufficientCapacityException e) {
-                    s_logger.info("Insufficient capacity ", e);
-                    if (!plan.getAvoids().add(e)) {
-                        if (e.getScope() == Volume.class || e.getScope() == Nic.class) {
-                            throw e;
-                        } else {
-                            s_logger.warn("unexpected InsufficientCapacityException : " + e.getScope().getName(), e);
-                        }
-                    }
-                } catch (Exception e) {
-                    s_logger.error("Failed to start instance " + vm, e);
-                    throw new CloudRuntimeException("Unable to start instance due to " + e.getMessage(), e);
-                } finally {
-                    if (startedVm == null && canRetry) {
-                        VmWorkJobVO.Step prevStep = work.getStep();
-                        _workJobDao.updateStep(work.getId(), VmWorkJobVO.Step.Release);
-                        if (prevStep == VmWorkJobVO.Step.Started || prevStep == VmWorkJobVO.Step.Starting) {
-                            cleanup(vmGuru, vmProfile, work, Event.OperationFailed, false, caller, account);
-                        } else {
-                            //if step is not starting/started, send cleanup command with force=true
-                            cleanup(vmGuru, vmProfile, work, Event.OperationFailed, true, caller, account);
-                        }
-                    }
-                }
-            }
-        } catch (NoTransitionException e1) {
-            throw new CloudRuntimeException(e1.getMessage());
-        } finally {
-            if (startedVm == null) {
-                try {
-                    changeState(vm, Event.OperationFailed, null, work, Step.Done);
-                } catch (NoTransitionException e) {
-                    throw new ConcurrentOperationException(e.getMessage());
-                }
-            }
-        }
-
-        if (startedVm == null) {
-            throw new CloudRuntimeException("Unable to start instance '" + vm.getHostName()
-                            + "' (" + vm.getUuid() + "), see management server log for details");
-        }
-    }
-    
-    @Override
-    public void stop(String vmUuid) {
-        try {
-            advanceStop(vmUuid, false);
-        } catch (OperationTimedoutException e) {
-            throw new CloudRuntimeException(e).add(VirtualMachine.class, vmUuid);
-        } catch (ConcurrentOperationException e) {
-            throw new CloudRuntimeException(e).add(VirtualMachine.class, vmUuid);
-        } catch (ResourceUnavailableException e) {
-            throw new CloudRuntimeException(e).add(VirtualMachine.class, vmUuid);
-        }
-    }
-
-    protected boolean sendStop(VirtualMachineGuru guru, VirtualMachineProfile profile, boolean force) {
-        VirtualMachine vm = profile.getVirtualMachine();
-        StopCommand stop = new StopCommand(vm);
-        try {
-            Answer answer = _agentMgr.send(vm.getHostId(), stop);
-            if (!answer.getResult()) {
-                s_logger.debug("Unable to stop VM due to " + answer.getDetails());
-                return false;
-            }
-
-            guru.finalizeStop(profile, (StopAnswer) answer);
-        } catch (AgentUnavailableException e) {
-            if (!force) {
-                return false;
-            }
-        } catch (OperationTimedoutException e) {
-            if (!force) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    protected boolean cleanup(VirtualMachineGuru guru, VirtualMachineProfile profile, VmWorkJobVO work, Event event, boolean force, User user,
-            Account account) {
-        VirtualMachine vm = profile.getVirtualMachine();
-        State state = vm.getState();
-        s_logger.debug("Cleaning up resources for the vm " + vm + " in " + state + " state");
-        if (state == State.Starting) {
-            VmWorkJobVO.Step step = work.getStep();
-            if (step == VmWorkJobVO.Step.Starting && !force) {
-                s_logger.warn("Unable to cleanup vm " + vm + "; work state is incorrect: " + step);
-                return false;
-            }
-
-            if (step == VmWorkJobVO.Step.Started || step == VmWorkJobVO.Step.Starting || step == VmWorkJobVO.Step.Release) {
-                if (vm.getHostId() != null) {
-                    if (!sendStop(guru, profile, force)) {
-                        s_logger.warn("Failed to stop vm " + vm + " in " + State.Starting + " state as a part of cleanup process");
-                        return false;
-                    }
-                }
-            }
-
-            if (step != VmWorkJobVO.Step.Release && step != VmWorkJobVO.Step.Prepare && step != VmWorkJobVO.Step.Started && step != VmWorkJobVO.Step.Starting) {
-                s_logger.debug("Cleanup is not needed for vm " + vm + "; work state is incorrect: " + step);
-                return true;
-            }
-        } else if (state == State.Stopping) {
-            if (vm.getHostId() != null) {
-                if (!sendStop(guru, profile, force)) {
-                    s_logger.warn("Failed to stop vm " + vm + " in " + State.Stopping + " state as a part of cleanup process");
-                    return false;
-                }
-            }
-        } else if (state == State.Migrating) {
-            if (vm.getHostId() != null) {
-                if (!sendStop(guru, profile, force)) {
-                    s_logger.warn("Failed to stop vm " + vm + " in " + State.Migrating + " state as a part of cleanup process");
-                    return false;
-                }
-            }
-            if (vm.getLastHostId() != null) {
-                if (!sendStop(guru, profile, force)) {
-                    s_logger.warn("Failed to stop vm " + vm + " in " + State.Migrating + " state as a part of cleanup process");
-                    return false;
-                }
-            }
-        } else if (state == State.Running) {
-            if (!sendStop(guru, profile, force)) {
-                s_logger.warn("Failed to stop vm " + vm + " in " + State.Running + " state as a part of cleanup process");
-                return false;
-            }
-        }
-
-        try {
-            _networkMgr.release(profile, force);
-            s_logger.debug("Successfully released network resources for the vm " + vm);
-        } catch (Exception e) {
-            s_logger.warn("Unable to release some network resources.", e);
-        }
-
-        _volumeMgr.release(profile);
-        s_logger.debug("Successfully cleanued up resources for the vm " + vm + " in " + state + " state");
-        return true;
-    }
-    
-    @Override
-    public void advanceStop(final String vmUuid, boolean forced) throws ResourceUnavailableException,
-            OperationTimedoutException, ConcurrentOperationException {
-        CallContext cc = CallContext.current();
-        Account account = cc.getCallingAccount();
-        User user = cc.getCallingUser();
-
-        final VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-    	VmWorkJobVO workJob = null;
-    	Transaction txn = Transaction.currentTxn();
-    	try {
-        	txn.start();
-        	
-        	_vmDao.lockRow(vm.getId(), true);
-        	
-        	List<VmWorkJobVO> pendingWorkJobs = _workJobDao.listPendingWorkJobs(
-                    VirtualMachine.Type.Instance, vm.getId(), VmWorkJobDispatcher.Start);
-        	
-        	if(pendingWorkJobs != null && pendingWorkJobs.size() > 0) {
-        		assert(pendingWorkJobs.size() == 1);
-        		workJob = pendingWorkJobs.get(0);
-        	} else {
-                workJob = new VmWorkJobVO(cc.getContextId());
-        	
-                workJob.setDispatcher(VmWorkJobDispatcher.VM_WORK_JOB_DISPATCHER);
-                workJob.setCmd(VmWorkJobDispatcher.Stop);
-        		
-        		workJob.setAccountId(account.getId());
-        		workJob.setUserId(user.getId());
-        		workJob.setStep(VmWorkJobVO.Step.Prepare);
-        		workJob.setVmType(vm.getType());
-        		workJob.setVmInstanceId(vm.getId());
-
-        		// save work context info (there are some duplications)
-        		VmWorkStop workInfo = new VmWorkStop();
-        		workInfo.setAccountId(account.getId());
-        		workInfo.setUserId(user.getId());
-        		workInfo.setVmId(vm.getId());
-        		workInfo.setForceStop(forced);
-        		workJob.setCmdInfo(ApiSerializerHelper.toSerializedString(workInfo));
-        		
-                _jobMgr.submitAsyncJob(workJob, VmWorkJobDispatcher.VM_WORK_QUEUE, vm.getId());
-        	}
-    	
-        	txn.commit();
-    	} catch(Throwable e) {
-    		s_logger.error("Unexpected exception", e);
-    		txn.rollback();
-    		throw new ConcurrentOperationException("Unhandled exception, converted to ConcurrentOperationException");
-    	}
-
-    	final long jobId = workJob.getId();
-    	AsyncJobExecutionContext.getCurrentExecutionContext().joinJob(jobId);
-    	
-    	_jobMgr.waitAndCheck(
-    		new String[] { TopicConstants.VM_POWER_STATE, TopicConstants.JOB_STATE },
-    		3000L, 600000L, new Predicate() {
-
-				@Override
-				public boolean checkCondition() {
-					VMInstanceVO instance = _vmDao.findById(vm.getId());
-					if(instance.getPowerState() == VirtualMachine.PowerState.PowerOff)
-						return true;
-			
-					VmWorkJobVO workJob = _workJobDao.findById(jobId);
-					if(workJob.getStatus() != AsyncJobConstants.STATUS_IN_PROGRESS)
-						return true;
-					
-					return false;
-				}
-    		});
-    	
-        try {
-            AsyncJobExecutionContext.getCurrentExecutionContext().disjoinJob(jobId);
-        } catch (InsufficientCapacityException e) {
-            throw new CloudRuntimeException("Should never ever happen on a stop.  Who threw this?", e);
-        }
-    }
-
-    public void orchestrateStop(String vmUuid, boolean forced) throws AgentUnavailableException,
-            OperationTimedoutException, ConcurrentOperationException {
-        CallContext context = CallContext.current();
-        User user = context.getCallingUser();
-        Account account = context.getCallingAccount();
-
-        VmWorkJobVO work = _workJobDao.findById(AsyncJobExecutionContext.getCurrentExecutionContext().getJob().getId());
-
-        final VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-        Long hostId = vm.getHostId();
-        if (hostId == null) {
-            if (!forced) {
-                if (s_logger.isDebugEnabled()) {
-                    s_logger.debug("HostId is null but this is not a forced stop, cannot stop vm " + vm + " with state:" + vm.getState());
-                }
-                return;
-            }
-            
-            try {
-                stateTransitTo(vm, Event.AgentReportStopped, null, null);
-            } catch (NoTransitionException e) {
-                s_logger.warn(e.getMessage());
-            }
-  
-            _workJobDao.updateStep(work.getId(), VmWorkJobVO.Step.Done);
-            return;
-        }
-
-        VirtualMachineGuru vmGuru = getVmGuru(vm);
-        VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
-
-        try {
-            if (!stateTransitTo(vm, Event.StopRequested, vm.getHostId())) {
-                throw new ConcurrentOperationException("VM is being operated on.");
-            }
-        } catch (NoTransitionException e1) {
-            if (!forced) {
-                throw new CloudRuntimeException("We cannot stop " + vm + " when it is in state " + vm.getState());
-            }
-            
-            State state = vm.getState();
-            boolean doCleanup = false;
-            if (s_logger.isDebugEnabled()) {
-                s_logger.debug("Unable to transition the state but we're moving on because it's forced stop");
-            }
-            if (state == State.Starting || state == State.Migrating) {
-                doCleanup = true;
-            } else if (state == State.Stopping) {
-                doCleanup = true;
-            }
-
-            if (doCleanup) {
-                if (cleanup(vmGuru, new VirtualMachineProfileImpl(vm), work, Event.StopRequested, forced, user, account)) {
-                    try {
-                        if (s_logger.isDebugEnabled()) {
-                            s_logger.debug("Updating work item to Done, id:" + work.getId());
-                        }
-                        changeState(vm, Event.AgentReportStopped, null, work, Step.Done);
-                        return;
-                    } catch (NoTransitionException e) {
-                        s_logger.warn("Unable to cleanup " + vm);
-                        return;
-                    }
-                } else {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("Failed to cleanup VM: " + vm);
-                    }
-                    throw new CloudRuntimeException("Failed to cleanup " + vm + " , current state " + vm.getState());
-                }
-            }
-        }
-
-        vmGuru.prepareStop(profile);
-        
-        StopCommand stop = new StopCommand(vm);
-        boolean stopped = false;
-        StopAnswer answer = null;
-        try {
-            answer = (StopAnswer) _agentMgr.send(vm.getHostId(), stop);
-            stopped = answer.getResult();
-            if (!stopped) {
-                throw new CloudRuntimeException("Unable to stop the virtual machine due to " + answer.getDetails());
-            }
-            vmGuru.finalizeStop(profile, answer);
-
-        } catch (AgentUnavailableException e) {
-        } catch (OperationTimedoutException e) {
-        } finally {
-            if (!stopped) {
-                if (!forced) {
-                    s_logger.warn("Unable to stop vm " + vm);
-                    try {
-                        stateTransitTo(vm, Event.OperationFailed, vm.getHostId());
-                    } catch (NoTransitionException e) {
-                        s_logger.warn("Unable to transition the state " + vm);
-                    }
-                    return;
-                } else {
-                    s_logger.warn("Unable to actually stop " + vm + " but continue with release because it's a force stop");
-                    vmGuru.finalizeStop(profile, answer);
-                }
-            }
-        }
-
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug(vm + " is stopped on the host.  Proceeding to release resource held.");
-        }
-
-        try {
-            _networkMgr.release(profile, forced);
-            s_logger.debug("Successfully released network resources for the vm " + vm);
-        } catch (Exception e) {
-            s_logger.warn("Unable to release some network resources.", e);
-        }
-
-        try {
-            if (vm.getHypervisorType() != HypervisorType.BareMetal) {
-                _volumeMgr.release(profile);
-                s_logger.debug("Successfully released storage resources for the vm " + vm);
-            }
-        } catch (Exception e) {
-            s_logger.warn("Unable to release storage resources.", e);
-        }
-
-        try {
-            if (work != null) {
-                if (s_logger.isDebugEnabled()) {
-                    s_logger.debug("Updating the outstanding work item to Done, id:" + work.getId());
-                }
-                _workJobDao.updateStep(work.getId(), VmWorkJobVO.Step.Done);
-            }
-
-            stateTransitTo(vm, Event.OperationSucceeded, null, null);
-            return;
-        } catch (NoTransitionException e) {
-            s_logger.warn(e.getMessage());
-            return;
-        }
-    }
-
-    private void setStateMachine() {
-        _stateMachine = VirtualMachine.State.getStateMachine();
-    }
-
-    protected boolean stateTransitTo(VMInstanceVO vm, VirtualMachine.Event e, Long hostId, String reservationId) throws NoTransitionException {
-        vm.setReservationId(reservationId);
-        return _stateMachine.transitTo(vm, e, new Pair<Long, Long>(vm.getHostId(), hostId), _vmDao);
-    }
-
-    @Override
-    public boolean stateTransitTo(VMInstanceVO vm, VirtualMachine.Event e, Long hostId) throws NoTransitionException {
-
-/*
- *  TODO ???
- * 
-        // if there are active vm snapshots task, state change is not allowed
-        if(_vmSnapshotMgr.hasActiveVMSnapshotTasks(vm.getId())) {
-            s_logger.error("State transit with event: " + e + " failed due to: " + vm.getInstanceName() + " has active VM snapshots tasks");
-            return false;
-        }
-*/
-        State oldState = vm.getState();
-        if (oldState == State.Starting) {
-            if (e == Event.OperationSucceeded) {
-                vm.setLastHostId(hostId);
-            }
-        } else if (oldState == State.Stopping) {
-            if (e == Event.OperationSucceeded) {
-                vm.setLastHostId(vm.getHostId());
-            }
-        }
-        return _stateMachine.transitTo(vm, e, new Pair<Long, Long>(vm.getHostId(), hostId), _vmDao);
-    }
-
-    @Override
-    public boolean destroy(String vmUuid) throws ResourceUnavailableException, OperationTimedoutException,
-            ConcurrentOperationException {
-        VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-        if (s_logger.isDebugEnabled()) {
-            s_logger.debug("Destroying vm " + vm);
-        }
-        if (vm == null || vm.getState() == State.Destroyed || vm.getState() == State.Expunging || vm.getRemoved() != null) {
-            if (s_logger.isDebugEnabled()) {
-                s_logger.debug("Unable to find vm or vm is destroyed: " + vm);
-            }
-            return true;
-        }
-
-        advanceStop(vmUuid, _forceStop.value());
-        
-        vm = _vmDao.findById(vm.getId());
-
-        if (!_vmSnapshotMgr.deleteAllVMSnapshots(vm.getId(),null)){
-            s_logger.debug("Unable to delete all snapshots for " + vm);
-            return false;
-        }
-        
-        try {
-            if (!stateTransitTo(vm, VirtualMachine.Event.DestroyRequested, vm.getHostId())) {
-                s_logger.debug("Unable to destroy the vm because it is not in the correct state: " + vm);
-                return false;
-            }
-        } catch (NoTransitionException e) {
-            s_logger.debug(e.getMessage());
-            return false;
-        }
-
-        return true;
-    }
-
-    protected boolean checkVmOnHost(VirtualMachine vm, long hostId) throws AgentUnavailableException, OperationTimedoutException {
-        CheckVirtualMachineAnswer answer = (CheckVirtualMachineAnswer) _agentMgr.send(hostId, new CheckVirtualMachineCommand(vm.getInstanceName()));
-        if (!answer.getResult() || answer.getState() == PowerState.PowerOff) {
-            return false;
-        }
-
-        return true;
-    }
-
-    @Override
-    public VirtualMachine storageMigration(String vmUuid, StoragePool destPool) {
-        VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-
-        try {
-            stateTransitTo(vm, VirtualMachine.Event.StorageMigrationRequested, null);
-        } catch (NoTransitionException e) {
-            s_logger.debug("Unable to migrate vm: " + e.toString());
-            throw new CloudRuntimeException("Unable to migrate vm: " + e.toString());
-        }
-
-        VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
-        boolean migrationResult = false;
-        try {
-            migrationResult = _volumeMgr.storageMigration(profile, destPool);
-
-            if (migrationResult) {
-                //if the vm is migrated to different pod in basic mode, need to reallocate ip
-
-                if (!vm.getPodIdToDeployIn().equals(destPool.getPodId())) {
-                    DataCenterDeployment plan = new DataCenterDeployment(vm.getDataCenterId(), destPool.getPodId(), null, null, null, null);
-                    VirtualMachineProfileImpl vmProfile = new VirtualMachineProfileImpl(vm, null, null, null, null);
-                    _networkMgr.reallocate(vmProfile, plan);
-                }
-
-                //when start the vm next time, don;'t look at last_host_id, only choose the host based on volume/storage pool
-                vm.setLastHostId(null);
-                vm.setPodId(destPool.getPodId());
-            } else {
-                s_logger.debug("Storage migration failed");
-            }
-        } catch (ConcurrentOperationException e) {
-            s_logger.debug("Failed to migration: " + e.toString());
-            throw new CloudRuntimeException("Failed to migration: " + e.toString());
-        } catch (InsufficientVirtualNetworkCapcityException e) {
-            s_logger.debug("Failed to migration: " + e.toString());
-            throw new CloudRuntimeException("Failed to migration: " + e.toString());
-        } catch (InsufficientAddressCapacityException e) {
-            s_logger.debug("Failed to migration: " + e.toString());
-            throw new CloudRuntimeException("Failed to migration: " + e.toString());
-        } catch (InsufficientCapacityException e) {
-            s_logger.debug("Failed to migration: " + e.toString());
-            throw new CloudRuntimeException("Failed to migration: " + e.toString());
-        } finally {
-            try {
-                stateTransitTo(vm, VirtualMachine.Event.AgentReportStopped, null);
-            } catch (NoTransitionException e) {
-                s_logger.debug("Failed to change vm state: " + e.toString());
-                throw new CloudRuntimeException("Failed to change vm state: " + e.toString());
-            }
-        }
-
-        return vm;
-    }
-
-    @Override
-    public VirtualMachine migrate(String vmUuid, long srcHostId, DeployDestination dest) throws ResourceUnavailableException, ConcurrentOperationException,
-            ManagementServerException,
-    	VirtualMachineMigrationException {
-        VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-        s_logger.info("Migrating " + vm + " to " + dest);
-        
-        return vm;
-        
-        /*
-                long dstHostId = dest.getHost().getId();
-                Host fromHost = _hostDao.findById(srcHostId);
-                if (fromHost == null) {
-                    s_logger.info("Unable to find the host to migrate from: " + srcHostId);
-                    throw new CloudRuntimeException("Unable to find the host to migrate from: " + srcHostId);
-                }
-
-                if (fromHost.getClusterId().longValue() != dest.getCluster().getId()) {
-                    s_logger.info("Source and destination host are not in same cluster, unable to migrate to host: " + dest.getHost().getId());
-                    throw new CloudRuntimeException("Source and destination host are not in same cluster, unable to migrate to host: " + dest.getHost().getId());
-                }
-
-                VirtualMachineGuru<T> vmGuru = getVmGuru(vm);
-
-                long vmId = vm.getId();
-                vm = vmGuru.findById(vmId);
-                if (vm == null) {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("Unable to find the vm " + vm);
-                    }
-                    throw new ManagementServerException("Unable to find a virtual machine with id " + vmId);
-                }
-
-                if (vm.getState() != State.Running) {
-                    if (s_logger.isDebugEnabled()) {
-                        s_logger.debug("VM is not Running, unable to migrate the vm " + vm);
-                    }
-                    throw new VirtualMachineMigrationException("VM is not Running, unable to migrate the vm currently " + vm + " , current state: " + vm.getState().toString());
-                }
-
-                short alertType = AlertManager.ALERT_TYPE_USERVM_MIGRATE;
-                if (VirtualMachine.Type.DomainRouter.equals(vm.getType())) {
-                    alertType = AlertManager.ALERT_TYPE_DOMAIN_ROUTER_MIGRATE;
-                } else if (VirtualMachine.Type.ConsoleProxy.equals(vm.getType())) {
-                    alertType = AlertManager.ALERT_TYPE_CONSOLE_PROXY_MIGRATE;
-                }
-
-        VirtualMachineProfile<VMInstanceVO> vmSrc = new VirtualMachineProfileImpl<VMInstanceVO>(vm);
-        for(NicProfile nic: _networkMgr.getNicProfiles(vm)){
-            vmSrc.addNic(nic);
-        }
-        
-                VirtualMachineProfile<VMInstanceVO> profile = new VirtualMachineProfileImpl<VMInstanceVO>(vm);
-                _networkMgr.prepareNicForMigration(profile, dest);
-                this.volumeMgr.prepareForMigration(profile, dest);
-
-                VirtualMachineTO to = toVmTO(profile);
-                PrepareForMigrationCommand pfmc = new PrepareForMigrationCommand(to);
-
-                VmWorkJobVO work = new VmWorkJobVO(UUID.randomUUID().toString(), _nodeId, State.Migrating, vm.getType(), vm.getId());
-                work.setStep(Step.Prepare);
-                work.setResourceType(VmWorkJobVO.ResourceType.Host);
-                work.setResourceId(dstHostId);
-                work = _workDao.persist(work);
-
-                PrepareForMigrationAnswer pfma = null;
-                try {
-                    pfma = (PrepareForMigrationAnswer) _agentMgr.send(dstHostId, pfmc);
-                    if (!pfma.getResult()) {
-                        String msg = "Unable to prepare for migration due to " + pfma.getDetails();
-                        pfma = null;
-                        throw new AgentUnavailableException(msg, dstHostId);
-                    }
-                } catch (OperationTimedoutException e1) {
-                    throw new AgentUnavailableException("Operation timed out", dstHostId);
-                } finally {
-                    if (pfma == null) {
-                _networkMgr.rollbackNicForMigration(vmSrc, profile);
-                        work.setStep(Step.Done);
-                        _workDao.update(work.getId(), work);
-                    }
-                }
-
-                vm.setLastHostId(srcHostId);
-                try {
-                    if (vm == null || vm.getHostId() == null || vm.getHostId() != srcHostId || !changeState(vm, Event.MigrationRequested, dstHostId, work, Step.Migrating)) {
-                _networkMgr.rollbackNicForMigration(vmSrc, profile);
-                        s_logger.info("Migration cancelled because state has changed: " + vm);
-                        throw new ConcurrentOperationException("Migration cancelled because state has changed: " + vm);
-                    }
-                } catch (NoTransitionException e1) {
-            _networkMgr.rollbackNicForMigration(vmSrc, profile);
-                    s_logger.info("Migration cancelled because " + e1.getMessage());
-                    throw new ConcurrentOperationException("Migration cancelled because " + e1.getMessage());
-                }
-
-                boolean migrated = false;
-                try {
-                    boolean isWindows = _guestOsCategoryDao.findById(_guestOsDao.findById(vm.getGuestOSId()).getCategoryId()).getName().equalsIgnoreCase("Windows");
-                    MigrateCommand mc = new MigrateCommand(vm.getInstanceName(), dest.getHost().getPrivateIpAddress(), isWindows);
-                    mc.setHostGuid(dest.getHost().getGuid());
-
-                    try {
-                        MigrateAnswer ma = (MigrateAnswer) _agentMgr.send(vm.getLastHostId(), mc);
-                        if (!ma.getResult()) {
-                            s_logger.error("Unable to migrate due to " + ma.getDetails());
-                            return null;
-                        }
-                    } catch (OperationTimedoutException e) {
-                        if (e.isActive()) {
-                            s_logger.warn("Active migration command so scheduling a restart for " + vm);
-                            _haMgr.scheduleRestart(vm, true);
-                        }
-                        throw new AgentUnavailableException("Operation timed out on migrating " + vm, dstHostId);
-                    }
-
-                    try {
-                        if (!changeState(vm, VirtualMachine.Event.OperationSucceeded, dstHostId, work, Step.Started)) {
-                            throw new ConcurrentOperationException("Unable to change the state for " + vm);
-                        }
-                    } catch (NoTransitionException e1) {
-                        throw new ConcurrentOperationException("Unable to change state due to " + e1.getMessage());
-                    }
-
-                    try {
-                        if (!checkVmOnHost(vm, dstHostId)) {
-                            s_logger.error("Unable to complete migration for " + vm);
-                            try {
-                                _agentMgr.send(srcHostId, new Commands(cleanup(vm)), null);
-                            } catch (AgentUnavailableException e) {
-                                s_logger.error("AgentUnavailableException while cleanup on source host: " + srcHostId);
-                            }
-                            cleanup(vmGuru, new VirtualMachineProfileImpl(vm), work, Event.AgentReportStopped, true, _accountMgr.getSystemUser(), _accountMgr.getSystemAccount());
-                            return null;
-                        }
-                    } catch (OperationTimedoutException e) {
-                    }
-
-                    migrated = true;
-                    return vm;
-                } finally {
-                    if (!migrated) {
-                        s_logger.info("Migration was unsuccessful.  Cleaning up: " + vm);
-                _networkMgr.rollbackNicForMigration(vmSrc, profile);
-
-                        _alertMgr.sendAlert(alertType, fromHost.getDataCenterId(), fromHost.getPodId(), "Unable to migrate vm " + vm.getInstanceName() + " from host " + fromHost.getName() + " in zone "
-                                + dest.getDataCenter().getName() + " and pod " + dest.getPod().getName(), "Migrate Command failed.  Please check logs.");
-                        try {
-                            _agentMgr.send(dstHostId, new Commands(cleanup(vm)), null);
-                        } catch (AgentUnavailableException ae) {
-                            s_logger.info("Looks like the destination Host is unavailable for cleanup");
-                        }
-
-                        try {
-                            stateTransitTo(vm, Event.OperationFailed, srcHostId);
-                        } catch (NoTransitionException e) {
-                            s_logger.warn(e.getMessage());
-                        }
-            }else{
-                _networkMgr.commitNicForMigration(vmSrc, profile);
-                    }
-
-                    work.setStep(Step.Done);
-                    _workDao.update(work.getId(), work);
-                }
-        */
-    }
-
-    private void filterPoolListForVolumesForMigration(VirtualMachineProfile profile, Host host, Map<Volume, StoragePool> volumeToPool) {
-        List<VolumeVO> allVolumes = _volsDao.findUsableVolumesForInstance(profile.getId());
-        for (VolumeVO volume : allVolumes) {
-            StoragePool dstPool = volumeToPool.get(volume);
-            DiskOfferingVO diskOffering = _entityMgr.findById(DiskOfferingVO.class, volume.getDiskOfferingId());
-            StoragePoolVO srcPool = _entityMgr.findById(StoragePoolVO.class, volume.getPoolId());
-            if (dstPool != null) {
-                // Check if pool is accessible from the destination host and disk offering with which the volume was
-                // created is compliant with the pool type.
-                if (_poolHostDao.findByPoolHost(dstPool.getId(), host.getId()) == null ||
-                        dstPool.isLocal() != diskOffering.getUseLocalStorage()) {
-                    // Cannot find a pool for the volume. Throw an exception.
-                    throw new CloudRuntimeException("Cannot migrate volume " + volume + " to storage pool " + dstPool +
-                            " while migrating vm to host " + host + ". Either the pool is not accessible from the " +
-                            "host or because of the offering with which the volume is created it cannot be placed on " +
-                            "the given pool.");
-                } else if (dstPool.getId() == srcPool.getId()){
-                    // If the pool to migrate too is the same as current pool, remove the volume from the list of
-                    // volumes to be migrated.
-                    volumeToPool.remove(volume);
-                }
-            } else {
-                // Find a suitable pool for the volume. Call the storage pool allocator to find the list of pools.
-                DiskProfile diskProfile = new DiskProfile(volume, diskOffering, profile.getHypervisorType());
-                DataCenterDeployment plan = new DataCenterDeployment(host.getDataCenterId(), host.getPodId(),
-                        host.getClusterId(), host.getId(), null, null);
-                ExcludeList avoid = new ExcludeList();
-                boolean currentPoolAvailable = false;
-
-                for (StoragePoolAllocator allocator : _storagePoolAllocators) {
-                    List<StoragePool> poolList = allocator.allocateToPool(diskProfile, profile, plan, avoid,
-                            StoragePoolAllocator.RETURN_UPTO_ALL);
-                    if (poolList != null && !poolList.isEmpty()) {
-                        // Volume needs to be migrated. Pick the first pool from the list. Add a mapping to migrate the
-                        // volume to a pool only if it is required; that is the current pool on which the volume resides
-                        // is not available on the destination host.
-                        if (poolList.contains(srcPool)) {
-                            currentPoolAvailable = true;
-                        } else {
-                            volumeToPool.put(volume, poolList.get(0));
-                        }
-
-                        break;
-                    }
-                }
-
-                if (!currentPoolAvailable && !volumeToPool.containsKey(volume)) {
-                    // Cannot find a pool for the volume. Throw an exception.
-                    throw new CloudRuntimeException("Cannot find a storage pool which is available for volume " +
-                            volume + " while migrating virtual machine " + profile.getVirtualMachine() + " to host " +
-                            host);
-                }
-            }
-        }
-    }
-
-    private void moveVmToMigratingState(VMInstanceVO vm, Long hostId, VmWorkJobVO work)
-            throws ConcurrentOperationException {
-        // Put the vm in migrating state.
-        try {
-            if (!changeState(vm, Event.MigrationRequested, hostId, work, Step.Migrating)) {
-                s_logger.info("Migration cancelled because state has changed: " + vm);
-                throw new ConcurrentOperationException("Migration cancelled because state has changed: " + vm);
-            }
-        } catch (NoTransitionException e) {
-            s_logger.info("Migration cancelled because " + e.getMessage());
-            throw new ConcurrentOperationException("Migration cancelled because " + e.getMessage());
-        }
-    }
-
-    private void moveVmOutofMigratingStateOnSuccess(VMInstanceVO vm, Long hostId, VmWorkJobVO work)
-            throws ConcurrentOperationException {
-        // Put the vm in running state.
-        try {
-            if (!changeState(vm, Event.OperationSucceeded, hostId, work, Step.Started)) {
-                s_logger.error("Unable to change the state for " + vm);
-                throw new ConcurrentOperationException("Unable to change the state for " + vm);
-            }
-        } catch (NoTransitionException e) {
-            s_logger.error("Unable to change state due to " + e.getMessage());
-            throw new ConcurrentOperationException("Unable to change state due to " + e.getMessage());
-        }
-    }
-
-    @Override
-    public VirtualMachine migrateWithStorage(String vmUuid, long srcHostId, long destHostId,
-            Map<Volume, StoragePool> volumeToPool) throws ResourceUnavailableException, ConcurrentOperationException,
-            ManagementServerException, VirtualMachineMigrationException {
-        CallContext context = CallContext.current();
-
-        VMInstanceVO vm = _vmDao.findByUuid(vmUuid);
-        HostVO srcHost = _entityMgr.findById(HostVO.class, srcHostId);
-        HostVO destHost = _entityMgr.findById(HostVO.class, destHostId);
-        VirtualMachineGuru vmGuru = getVmGuru(vm);
-
-        DataCenterVO dc = _entityMgr.findById(DataCenterVO.class, destHost.getDataCenterId());
-        HostPodVO pod = _entityMgr.findById(HostPodVO.class, destHost.getPodId());
-        Cluster cluster = _entityMgr.findById(ClusterVO.class, destHost.getClusterId());
-        DeployDestination destination = new DeployDestination(dc, pod, cluster, destHost);
-
-        // Create a map of which volume should go in which storage pool.
-        VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
-        filterPoolListForVolumesForMigration(profile, destHost, volumeToPool);
-
-        // If none of the volumes have to be migrated, fail the call. Administrator needs to make a call for migrating
-        // a vm and not migrating a vm with storage.
-        if (volumeToPool.isEmpty()) {
-            throw new InvalidParameterValueException("Migration of the vm " + vm + "from host " + srcHost +
-                    " to destination host " + destHost + " doesn't involve migrating the volumes.");
-        }
-
-        short alertType = AlertManager.ALERT_TYPE_USERVM_MIGRATE;
-        if (VirtualMachine.Type.DomainRouter.equals(vm.getType())) {
-            alertType = AlertManager.ALERT_TYPE_DOMAIN_ROUTER_MIGRATE;
-        } else if (VirtualMachine.Type.ConsoleProxy.equals(vm.getType())) {
-            alertType = AlertManager.ALERT_TYPE_CONSOLE_PROXY_MIGRATE;
-        }
-
-        _networkMgr.prepareNicForMigration(profile, destination);
-        _volumeMgr.prepareForMigration(profile, destination);
-        HypervisorGuru hvGuru = _hvGuruMgr.getGuru(vm.getHypervisorType());
-        VirtualMachineTO to = hvGuru.implement(profile);
-
-        VmWorkJobVO work = new VmWorkJobVO(context.getContextId());
-//        VmWorkJobVO work = new VmWorkJobVO(UUID.randomUUID().toString(), _nodeId, State.Migrating, vm.getType(), vm.getId());
-//        work.setStep(Step.Prepare);
-//        work.setResourceType(ItWorkVO.ResourceType.Host);
-//        work.setResourceId(destHostId);
-//        work = _workDao.persist(work);
-
-        // Put the vm in migrating state.
-        vm.setLastHostId(srcHostId);
-        moveVmToMigratingState(vm, destHostId, work);
-
-        boolean migrated = false;
-        try {
-            // Migrate the vm and its volume.
-            _volumeMgr.migrateVolumes(vm, to, srcHost, destHost, volumeToPool);
-
-            // Put the vm back to running state.
-            moveVmOutofMigratingStateOnSuccess(vm, destHost.getId(), work);
-
-            try {
-                if (!checkVmOnHost(vm, destHostId)) {
-                    s_logger.error("Vm not found on destination host. Unable to complete migration for " + vm);
-                    try {
-                        _agentMgr.send(srcHostId, new Commands(cleanup(vm.getInstanceName())), null);
-                    } catch (AgentUnavailableException e) {
-                        s_logger.error("AgentUnavailableException while cleanup on source host: " + srcHostId);
-                    }
-                    cleanup(vmGuru, new VirtualMachineProfileImpl(vm), work, Event.AgentReportStopped, true,
-                            _accountMgr.getSystemUser(), _accountMgr.getSystemAccount());
-                    return null;
-                }
-            } catch (OperationTimedoutException e) {
-                s_logger.warn("Error while checking the vm " + vm + " is on host " + destHost, e);
-            }
-
-            migrated = true;
-            return vm;
-        } finally {
-            if (!migrated) {
-                s_logger.info("Migration was unsuccessful.  Cleaning up: " + vm);
-                _alertMgr.sendAlert(alertType, srcHost.getDataCenterId(), srcHost.getPodId(), "Unable to migrate vm " +
-                        vm.getInstanceName() + " from host " + srcHost.getName() + " in zone " + dc.getName() +
-                        " and pod " + dc.getName(), "Migrate Command failed.  Please check logs.");
-                try {
-                    _agentMgr.send(destHostId, new Commands(cleanup(vm.getInstanceName())), null);
-                    stateTransitTo(vm, Event.OperationFailed, srcHostId);
-                } catch (AgentUnavailableException e) {
-                    s_logger.warn("Looks like the destination Host is unavailable for cleanup.", e);
-                } catch (NoTransitionException e) {
-                    s_logger.error("Error while transitioning vm from migrating to running state.", e);
-                }
-            }
-
-            work.setStep(Step.Done);
-            // FIXME  _workDao.update(work.getId(), work);
-        }
-    }
-
-    @Override
-    public VirtualMachineTO toVmTO(VirtualMachineProfile profile) {
-        HypervisorGuru hvGuru = _hvGuruMgr.getGuru(profile.getVirtualMachine().getHypervisorType());
-        VirtualMachineTO to = hvGuru.implement(profile);
-        return to;
-    }
-
-    protected void cancelWorkItems(long nodeId) {
-        /*
-                GlobalLock scanLock = GlobalLock.getInternLock("vmmgr.cancel.workitem");
-
-                try {
-                    if (scanLock.lock(3)) {
-                        try {
-                            List<VmWorkJobVO> works = _workDao.listWorkInProgressFor(nodeId);
-                            for (VmWorkJobVO work : works) {
-                                s_logger.info("Handling unfinished work item: " + work);
-                                try {
-                                    VMInstanceVO vm = _vmDao.findById(work.getInstanceId());
-                                    if (vm != null) {
-                                        if (work.getType() == State.Starting) {
-                                            _haMgr.scheduleRestart(vm, true);
-                                            work.setManagementServerId(_nodeId);
-                                            _workDao.update(work.getId(), work);
-                                        } else if (work.getType() == State.Stopping) {
-                                            _haMgr.scheduleStop(vm, vm.getHostId(), WorkType.CheckStop);
-                                            work.setManagementServerId(_nodeId);
-                                            _workDao.update(work.getId(), work);
-                                        } else if (work.getType() == State.Migrating) {
-                                            _haMgr.scheduleMigration(vm);
-                                            work.setStep(Step.Done);
-                                            _workDao.update(work.getId(), work);
-                                        }
-                                    }
-                                } catch (Exception e) {
-                                    s_logger.error("Error while handling " + work, e);
-                                }
-                            }
-                        } finally {
-                            scanLock.unlock();
-                        }
-                    }
-                } finally {
-                    scanLock.releaseRef();
-                }
-        */
-    }
-
-    @Override
-    public boolean migrateAway(VirtualMachine.Type vmType, long vmId, long srcHostId) throws InsufficientServerCapacityException, VirtualMachineMigrationException {
-        CallContext cc = CallContext.current();
-        VMInstanceVO vm = _vmDao.findById(vmId);
-        if (vm == null) {
-            s_logger.debug("Unable to find a VM for " + vmId);
-            return true;
-        }
-
-        VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
-
-        Long hostId = vm.getHostId();
-        if (hostId == null) {
-            s_logger.debug("Unable to migrate because the VM doesn't have a host id: " + vm);
-            return true;
-        }
-
-        Host host = _hostDao.findById(hostId);
-
-        DataCenterDeployment plan = new DataCenterDeployment(host.getDataCenterId(), host.getPodId(), host.getClusterId(), null, null, null);
-        ExcludeList excludes = new ExcludeList();
-        excludes.addHost(hostId);
-
-        DeployDestination dest = null;
-        while (true) {
-
-            try {
-                dest = _dpMgr.planDeployment(profile, plan, excludes);
-            } catch (AffinityConflictException e2) {
-                s_logger.warn("Unable to create deployment, affinity rules associted to the VM conflict", e2);
-                throw new CloudRuntimeException(
-                        "Unable to create deployment, affinity rules associted to the VM conflict");
-                }
-
-                if (dest != null) {
-                    if (s_logger.isDebugEnabled()) {
-                    s_logger.debug("Found destination " + dest + " for migrating to.");
-                }
-            } else {
-                if (s_logger.isDebugEnabled()) {
-                    s_logger.debug("Unable to find destination for migrating the vm " + profile);
-                }
-                throw new InsufficientServerCapacityException("Unable to find a server to migrate to.", host.getClusterId());
-            }
-
-            excludes.addHost(dest.getHost().getId());
-            VirtualMachine vmInstance = null;
-            try {
-                vmInstance = migrate(vm.getUuid(), srcHostId, dest);
-            } c

<TRUNCATED>

Mime
View raw message