http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d4039743/server/test/com/cloud/vm/VirtualMachineManagerImplTest.java ---------------------------------------------------------------------- diff --cc server/test/com/cloud/vm/VirtualMachineManagerImplTest.java index 8e97788,dd51e74..8a5e3ae --- a/server/test/com/cloud/vm/VirtualMachineManagerImplTest.java +++ b/server/test/com/cloud/vm/VirtualMachineManagerImplTest.java @@@ -17,36 -17,89 +17,86 @@@ package com.cloud.vm; ++import static org.mockito.Matchers.any; ++import static org.mockito.Matchers.anyLong; ++import static org.mockito.Matchers.isA; ++import static org.mockito.Mockito.doNothing; ++import static org.mockito.Mockito.mock; ++import static org.mockito.Mockito.when; ++ ++import java.util.HashMap; ++import java.util.Iterator; ++import java.util.List; ++import java.util.Map; ++ ++import org.junit.Before; ++import org.junit.Test; ++import org.mockito.Mock; ++import org.mockito.MockitoAnnotations; ++import org.mockito.Spy; ++ ++import org.apache.cloudstack.api.command.user.vm.RestoreVMCmd; ++import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao; ++import org.apache.cloudstack.storage.datastore.db.StoragePoolVO; ++ import com.cloud.agent.AgentManager; import com.cloud.agent.api.Answer; -import com.cloud.agent.api.ScaleVmAnswer; -import com.cloud.agent.api.ScaleVmCommand; -import com.cloud.capacity.CapacityManager; -import com.cloud.configuration.ConfigurationManager; -import com.cloud.configuration.dao.ConfigurationDao; -import com.cloud.deploy.DeployDestination; -import com.cloud.host.HostVO; -import com.cloud.host.dao.HostDao; -import com.cloud.service.ServiceOfferingVO; -import com.cloud.storage.VMTemplateVO; -import com.cloud.storage.VolumeManager; -import com.cloud.storage.VolumeVO; -import com.cloud.agent.api.PrepareForMigrationAnswer; -import com.cloud.agent.api.PrepareForMigrationCommand; ++import com.cloud.agent.api.CheckVirtualMachineAnswer; ++import com.cloud.agent.api.CheckVirtualMachineCommand; + import com.cloud.agent.api.MigrateWithStorageAnswer; + import com.cloud.agent.api.MigrateWithStorageCommand; ++import com.cloud.agent.api.MigrateWithStorageCompleteAnswer; ++import com.cloud.agent.api.MigrateWithStorageCompleteCommand; + import com.cloud.agent.api.MigrateWithStorageReceiveAnswer; + import com.cloud.agent.api.MigrateWithStorageReceiveCommand; + import com.cloud.agent.api.MigrateWithStorageSendAnswer; + import com.cloud.agent.api.MigrateWithStorageSendCommand; -import com.cloud.agent.api.MigrateWithStorageCompleteAnswer; -import com.cloud.agent.api.MigrateWithStorageCompleteCommand; -import com.cloud.agent.api.CheckVirtualMachineAnswer; -import com.cloud.agent.api.CheckVirtualMachineCommand; ++import com.cloud.agent.api.PrepareForMigrationAnswer; ++import com.cloud.agent.api.PrepareForMigrationCommand; +import com.cloud.agent.api.ScaleVmAnswer; +import com.cloud.agent.api.ScaleVmCommand; import com.cloud.capacity.CapacityManager; import com.cloud.configuration.ConfigurationManager; import com.cloud.configuration.dao.ConfigurationDao; + import com.cloud.dc.dao.ClusterDao; + import com.cloud.dc.dao.DataCenterDao; + import com.cloud.dc.dao.HostPodDao; +import com.cloud.deploy.DeployDestination; + import com.cloud.exception.ConcurrentOperationException; + import com.cloud.exception.ManagementServerException; ++import com.cloud.exception.OperationTimedoutException; + import com.cloud.exception.ResourceUnavailableException; + import com.cloud.exception.VirtualMachineMigrationException; -import com.cloud.exception.OperationTimedoutException; import com.cloud.host.HostVO; 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.hypervisor.Hypervisor.HypervisorType; + import com.cloud.network.NetworkManager; +import com.cloud.service.ServiceOfferingVO; + import com.cloud.storage.DiskOfferingVO; + import com.cloud.storage.StoragePoolHostVO; +import com.cloud.storage.VMTemplateVO; import com.cloud.storage.VolumeManager; import com.cloud.storage.VolumeVO; + import com.cloud.storage.dao.DiskOfferingDao; + import com.cloud.storage.dao.StoragePoolHostDao; import com.cloud.storage.dao.VMTemplateDao; import com.cloud.storage.dao.VolumeDao; --import com.cloud.user.*; ++import com.cloud.user.Account; ++import com.cloud.user.AccountManager; ++import com.cloud.user.AccountVO; ++import com.cloud.user.UserVO; import com.cloud.user.dao.AccountDao; import com.cloud.user.dao.UserDao; -import com.cloud.utils.exception.CloudRuntimeException; -import com.cloud.vm.dao.UserVmDao; -import com.cloud.vm.dao.VMInstanceDao; -import org.apache.cloudstack.api.command.user.vm.RestoreVMCmd; -import org.apache.cloudstack.api.command.user.vm.ScaleVMCmd; + import com.cloud.utils.Pair; import com.cloud.utils.exception.CloudRuntimeException; ++import com.cloud.vm.VirtualMachine.Event; ++import com.cloud.vm.VirtualMachine.PowerState; ++import com.cloud.vm.VirtualMachine.State; import com.cloud.vm.dao.UserVmDao; import com.cloud.vm.dao.VMInstanceDao; - import org.apache.cloudstack.api.command.user.vm.RestoreVMCmd; - import org.junit.Test; - import org.junit.Before; - import org.mockito.Mock; - import org.mockito.MockitoAnnotations; - import org.mockito.Spy; - import static org.mockito.Mockito.*; - import java.util.List; + import com.cloud.vm.snapshot.VMSnapshotManager; -import com.cloud.vm.VirtualMachine.Event; -import com.cloud.vm.VirtualMachine.State; - -import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao; -import org.apache.cloudstack.storage.datastore.db.StoragePoolVO; - -import org.junit.Test; -import org.junit.Before; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.mockito.Spy; -import static org.mockito.Matchers.anyLong; -import static org.mockito.Mockito.*; - -import java.lang.reflect.Field; -import java.util.List; -import java.util.Map; -import java.util.HashMap; -import java.util.Iterator; public class VirtualMachineManagerImplTest { @@@ -116,10 -187,18 +184,20 @@@ _vmMgr._capacityMgr = _capacityMgr; _vmMgr._hostDao = _hostDao; _vmMgr._nodeId = 1L; - /* ++/* _vmMgr._workDao = _workDao; - */ ++*/ _vmMgr._agentMgr = _agentMgr; + _vmMgr._podDao = _podDao; + _vmMgr._clusterDao = _clusterDao; + _vmMgr._dcDao = _dcDao; + _vmMgr._diskOfferingDao = _diskOfferingDao; + _vmMgr._storagePoolDao = _storagePoolDao; + _vmMgr._poolHostDao= _poolHostDao; + _vmMgr._networkMgr = _networkMgr; + _vmMgr._hvGuruMgr = _hvGuruMgr; + _vmMgr._vmSnapshotMgr = _vmSnapshotMgr; + _vmMgr._vmDao = _vmInstanceDao; when(_vmMock.getId()).thenReturn(314l); when(_vmInstance.getId()).thenReturn(1L); @@@ -202,5 -281,155 +280,155 @@@ return serviceOffering; } + private void initializeMockConfigForMigratingVmWithVolumes() throws OperationTimedoutException, + ResourceUnavailableException { + + // Mock the source and destination hosts. + when(_srcHostMock.getId()).thenReturn(5L); + when(_destHostMock.getId()).thenReturn(6L); + when(_hostDao.findById(5L)).thenReturn(_srcHostMock); + when(_hostDao.findById(6L)).thenReturn(_destHostMock); + + // Mock the vm being migrated. + when(_vmMock.getId()).thenReturn(1L); + when(_vmMock.getHypervisorType()).thenReturn(HypervisorType.XenServer); + when(_vmMock.getState()).thenReturn(State.Running).thenReturn(State.Running).thenReturn(State.Migrating) + .thenReturn(State.Migrating); + when(_vmMock.getHostId()).thenReturn(5L); + when(_vmInstance.getId()).thenReturn(1L); + when(_vmInstance.getServiceOfferingId()).thenReturn(2L); + when(_vmInstance.getInstanceName()).thenReturn("myVm"); + when(_vmInstance.getHostId()).thenReturn(5L); + when(_vmInstance.getType()).thenReturn(VirtualMachine.Type.User); + when(_vmInstance.getState()).thenReturn(State.Running).thenReturn(State.Running).thenReturn(State.Migrating) + .thenReturn(State.Migrating); + + // Mock the work item. + when(_workDao.persist(any(ItWorkVO.class))).thenReturn(_work); + when(_workDao.update("1", _work)).thenReturn(true); + when(_work.getId()).thenReturn("1"); + doNothing().when(_work).setStep(ItWorkVO.Step.Done); + + // Mock the vm guru and the user vm object that gets returned. + _vmMgr._vmGurus = new HashMap<VirtualMachine.Type, VirtualMachineGuru<? extends VMInstanceVO>>(); + UserVmManagerImpl userVmManager = mock(UserVmManagerImpl.class); + _vmMgr.registerGuru(VirtualMachine.Type.User, userVmManager); + when(userVmManager.findById(anyLong())).thenReturn(_vmMock); + + // Mock the iteration over all the volumes of an instance. + Iterator<VolumeVO> volumeIterator = mock(Iterator.class); + when(_volsDao.findUsableVolumesForInstance(anyLong())).thenReturn(_rootVols); + when(_rootVols.iterator()).thenReturn(volumeIterator); + when(volumeIterator.hasNext()).thenReturn(true, false); + when(volumeIterator.next()).thenReturn(_volumeMock); + + // Mock the disk offering and pool objects for a volume. + when(_volumeMock.getDiskOfferingId()).thenReturn(5L); + when(_volumeMock.getPoolId()).thenReturn(200L); + when(_diskOfferingDao.findById(anyLong())).thenReturn(_diskOfferingMock); + when(_storagePoolDao.findById(anyLong())).thenReturn(_srcStoragePoolMock); + + // Mock the volume to pool mapping. + when(_volumeToPoolMock.get(_volumeMock)).thenReturn(_destStoragePoolMock); + when(_destStoragePoolMock.getId()).thenReturn(201L); + when(_srcStoragePoolMock.getId()).thenReturn(200L); + when(_destStoragePoolMock.isLocal()).thenReturn(false); + when(_diskOfferingMock.getUseLocalStorage()).thenReturn(false); + when(_poolHostDao.findByPoolHost(anyLong(), anyLong())).thenReturn(mock(StoragePoolHostVO.class)); + // Mock hypervisor guru. + HypervisorGuru guruMock = mock(HypervisorGuru.class); + when(_hvGuruMgr.getGuru(HypervisorType.XenServer)).thenReturn(guruMock); + + when(_srcHostMock.getClusterId()).thenReturn(3L); + when(_destHostMock.getClusterId()).thenReturn(3L); + + // Mock the commands and answers to the agent. + PrepareForMigrationAnswer prepAnswerMock = mock(PrepareForMigrationAnswer.class); + when(prepAnswerMock.getResult()).thenReturn(true); + when(_agentMgr.send(anyLong(), isA(PrepareForMigrationCommand.class))).thenReturn(prepAnswerMock); + + MigrateWithStorageAnswer migAnswerMock = mock(MigrateWithStorageAnswer.class); + when(migAnswerMock.getResult()).thenReturn(true); + when(_agentMgr.send(anyLong(), isA(MigrateWithStorageCommand.class))).thenReturn(migAnswerMock); + + MigrateWithStorageReceiveAnswer migRecAnswerMock = mock(MigrateWithStorageReceiveAnswer.class); + when(migRecAnswerMock.getResult()).thenReturn(true); + when(_agentMgr.send(anyLong(), isA(MigrateWithStorageReceiveCommand.class))).thenReturn(migRecAnswerMock); + + MigrateWithStorageSendAnswer migSendAnswerMock = mock(MigrateWithStorageSendAnswer.class); + when(migSendAnswerMock.getResult()).thenReturn(true); + when(_agentMgr.send(anyLong(), isA(MigrateWithStorageSendCommand.class))).thenReturn(migSendAnswerMock); + + MigrateWithStorageCompleteAnswer migCompleteAnswerMock = mock(MigrateWithStorageCompleteAnswer.class); + when(migCompleteAnswerMock.getResult()).thenReturn(true); + when(_agentMgr.send(anyLong(), isA(MigrateWithStorageCompleteCommand.class))).thenReturn(migCompleteAnswerMock); + + CheckVirtualMachineAnswer checkVmAnswerMock = mock(CheckVirtualMachineAnswer.class); + when(checkVmAnswerMock.getResult()).thenReturn(true); - when(checkVmAnswerMock.getState()).thenReturn(State.Running); ++ when(checkVmAnswerMock.getState()).thenReturn(PowerState.PowerOn); + when(_agentMgr.send(anyLong(), isA(CheckVirtualMachineCommand.class))).thenReturn(checkVmAnswerMock); + + // Mock the state transitions of vm. + Pair<Long, Long> opaqueMock = new Pair<Long, Long> (_vmMock.getHostId(), _destHostMock.getId()); + when(_vmSnapshotMgr.hasActiveVMSnapshotTasks(anyLong())).thenReturn(false); + when(_vmInstanceDao.updateState(State.Running, Event.MigrationRequested, State.Migrating, _vmMock, opaqueMock)) + .thenReturn(true); + when(_vmInstanceDao.updateState(State.Migrating, Event.OperationSucceeded, State.Running, _vmMock, opaqueMock)) + .thenReturn(true); + } + + // Check migration of a vm with its volumes within a cluster. + @Test + public void testMigrateWithVolumeWithinCluster() throws ResourceUnavailableException, ConcurrentOperationException, + ManagementServerException, VirtualMachineMigrationException, OperationTimedoutException { + + initializeMockConfigForMigratingVmWithVolumes(); + when(_srcHostMock.getClusterId()).thenReturn(3L); + when(_destHostMock.getClusterId()).thenReturn(3L); + + _vmMgr.migrateWithStorage(_vmInstance, _srcHostMock.getId(), _destHostMock.getId(), _volumeToPoolMock); + } + + // Check migration of a vm with its volumes across a cluster. + @Test + public void testMigrateWithVolumeAcrossCluster() throws ResourceUnavailableException, ConcurrentOperationException, + ManagementServerException, VirtualMachineMigrationException, OperationTimedoutException { + + initializeMockConfigForMigratingVmWithVolumes(); + when(_srcHostMock.getClusterId()).thenReturn(3L); + when(_destHostMock.getClusterId()).thenReturn(4L); + + _vmMgr.migrateWithStorage(_vmInstance, _srcHostMock.getId(), _destHostMock.getId(), _volumeToPoolMock); + } + + // Check migration of a vm fails when src and destination pool are not of same type; that is, one is shared and + // other is local. + @Test(expected=CloudRuntimeException.class) + public void testMigrateWithVolumeFail1() throws ResourceUnavailableException, ConcurrentOperationException, + ManagementServerException, VirtualMachineMigrationException, OperationTimedoutException { + + initializeMockConfigForMigratingVmWithVolumes(); + when(_srcHostMock.getClusterId()).thenReturn(3L); + when(_destHostMock.getClusterId()).thenReturn(3L); + + when(_destStoragePoolMock.isLocal()).thenReturn(true); + when(_diskOfferingMock.getUseLocalStorage()).thenReturn(false); + + _vmMgr.migrateWithStorage(_vmInstance, _srcHostMock.getId(), _destHostMock.getId(), _volumeToPoolMock); + } + + // Check migration of a vm fails when vm is not in Running state. + @Test(expected=ConcurrentOperationException.class) + public void testMigrateWithVolumeFail2() throws ResourceUnavailableException, ConcurrentOperationException, + ManagementServerException, VirtualMachineMigrationException, OperationTimedoutException { + + initializeMockConfigForMigratingVmWithVolumes(); + when(_srcHostMock.getClusterId()).thenReturn(3L); + when(_destHostMock.getClusterId()).thenReturn(3L); + + when(_vmMock.getState()).thenReturn(State.Stopped); + + _vmMgr.migrateWithStorage(_vmInstance, _srcHostMock.getId(), _destHostMock.getId(), _volumeToPoolMock); + } }
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d4039743/server/test/com/cloud/vm/VmWorkMockVirtualMachineManagerImpl.java ---------------------------------------------------------------------- diff --cc server/test/com/cloud/vm/VmWorkMockVirtualMachineManagerImpl.java index c078e39,0000000..4f992d9 mode 100644,000000..100644 --- a/server/test/com/cloud/vm/VmWorkMockVirtualMachineManagerImpl.java +++ b/server/test/com/cloud/vm/VmWorkMockVirtualMachineManagerImpl.java @@@ -1,421 -1,0 +1,432 @@@ +// 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.Collection; +import java.util.List; +import java.util.Map; + +import javax.inject.Inject; +import javax.naming.ConfigurationException; + - import org.apache.cloudstack.framework.messagebus.MessageBus; +import org.apache.log4j.Logger; + ++import org.apache.cloudstack.framework.messagebus.MessageBus; ++import org.apache.cloudstack.storage.datastore.db.StoragePoolVO; ++ +import com.cloud.agent.api.to.NicTO; +import com.cloud.agent.api.to.VirtualMachineTO; +import com.cloud.async.AsyncJobConstants; +import com.cloud.async.AsyncJobExecutionContext; +import com.cloud.deploy.DeployDestination; +import com.cloud.deploy.DeploymentPlan; +import com.cloud.exception.AgentUnavailableException; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.InsufficientServerCapacityException; +import com.cloud.exception.ManagementServerException; +import com.cloud.exception.OperationTimedoutException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.exception.VirtualMachineMigrationException; +import com.cloud.hypervisor.Hypervisor.HypervisorType; +import com.cloud.network.Network; +import com.cloud.network.dao.NetworkVO; +import com.cloud.offering.ServiceOffering; +import com.cloud.service.ServiceOfferingVO; +import com.cloud.storage.DiskOfferingVO; +import com.cloud.storage.StoragePool; +import com.cloud.storage.VMTemplateVO; ++import com.cloud.storage.VolumeVO; +import com.cloud.user.Account; +import com.cloud.user.User; +import com.cloud.utils.Pair; +import com.cloud.utils.fsm.NoTransitionException; +import com.cloud.vm.VirtualMachine.Event; +import com.cloud.vm.VirtualMachine.Type; +import com.cloud.vm.VirtualMachineProfile.Param; + +public class VmWorkMockVirtualMachineManagerImpl implements VirtualMachineManager { + private static final Logger s_logger = Logger.getLogger(VmWorkMockVirtualMachineManagerImpl.class); + + @Inject MessageBus _msgBus; + + @Override + public String getName() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void setName(String name) { + // TODO Auto-generated method stub + } + + @Override + public void setConfigParams(Map<String, Object> params) { + // TODO Auto-generated method stub + + } + + @Override + public Map<String, Object> getConfigParams() { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getRunLevel() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public void setRunLevel(int level) { + // TODO Auto-generated method stub + + } + + @Override + public boolean configure(String name, Map<String, Object> params) + throws ConfigurationException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean start() { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean stop() { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> T allocate(T vm, VMTemplateVO template, + ServiceOfferingVO serviceOffering, + Pair<? extends DiskOfferingVO, Long> rootDiskOffering, + List<Pair<DiskOfferingVO, Long>> dataDiskOfferings, + List<Pair<NetworkVO, NicProfile>> networks, + Map<Param, Object> params, DeploymentPlan plan, + HypervisorType hyperType, Account owner) + throws InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T allocate(T vm, VMTemplateVO template, + ServiceOfferingVO serviceOffering, Long rootSize, + Pair<DiskOfferingVO, Long> dataDiskOffering, + List<Pair<NetworkVO, NicProfile>> networks, DeploymentPlan plan, + HypervisorType hyperType, Account owner) + throws InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T allocate(T vm, VMTemplateVO template, + ServiceOfferingVO serviceOffering, + List<Pair<NetworkVO, NicProfile>> networkProfiles, + DeploymentPlan plan, HypervisorType hyperType, Account owner) + throws InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T start(T vm, Map<Param, Object> params, + User caller, Account account) throws InsufficientCapacityException, + ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T start(T vm, Map<Param, Object> params, + User caller, Account account, DeploymentPlan planToDeploy) + throws InsufficientCapacityException, ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> boolean stop(T vm, User caller, + Account account) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> boolean expunge(T vm, User caller, + Account account) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> void registerGuru(Type type, + VirtualMachineGuru<T> guru) { + // TODO Auto-generated method stub + + } + + @Override + public Collection<VirtualMachineGuru<? extends VMInstanceVO>> getRegisteredGurus() { + // TODO Auto-generated method stub + return null; + } + ++ @Override + public <T extends VMInstanceVO> VirtualMachineGuru<T> getVmGuru(T vm) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean stateTransitTo(VMInstanceVO vm, Event e, Long hostId) + throws NoTransitionException { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> T advanceStart(T vm, + Map<Param, Object> params, User caller, Account account) + throws InsufficientCapacityException, ResourceUnavailableException, + ConcurrentOperationException, OperationTimedoutException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T advanceStart(T vm, + Map<Param, Object> params, User caller, Account account, + DeploymentPlan planToDeploy) throws InsufficientCapacityException, + ResourceUnavailableException, ConcurrentOperationException, + OperationTimedoutException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> boolean advanceStop(T vm, boolean forced, + User caller, Account account) throws ResourceUnavailableException, + OperationTimedoutException, ConcurrentOperationException { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> boolean advanceExpunge(T vm, User caller, + Account account) throws ResourceUnavailableException, + OperationTimedoutException, ConcurrentOperationException { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> boolean remove(T vm, User caller, + Account account) { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> boolean destroy(T vm, User caller, + Account account) throws AgentUnavailableException, + OperationTimedoutException, ConcurrentOperationException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean migrateAway(Type type, long vmid, long hostId) + throws InsufficientServerCapacityException, + VirtualMachineMigrationException { + // TODO Auto-generated method stub + return false; + } + + @Override + public <T extends VMInstanceVO> T migrate(T vm, long srcHostId, + DeployDestination dest) throws ResourceUnavailableException, + ConcurrentOperationException, ManagementServerException, + VirtualMachineMigrationException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T reboot(T vm, Map<Param, Object> params, + User caller, Account account) throws InsufficientCapacityException, + ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T advanceReboot(T vm, + Map<Param, Object> params, User caller, Account account) + throws InsufficientCapacityException, ResourceUnavailableException, + ConcurrentOperationException, OperationTimedoutException { + // TODO Auto-generated method stub + return null; + } + + @Override + public VMInstanceVO findByIdAndType(Type type, long vmId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean isVirtualMachineUpgradable(VirtualMachine vm, + ServiceOffering offering) { + // TODO Auto-generated method stub + return false; + } + + @Override + public VMInstanceVO findById(long vmId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T storageMigration(T vm, + StoragePool storagePoolId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public void checkIfCanUpgrade(VirtualMachine vmInstance, + long newServiceOfferingId) { + // TODO Auto-generated method stub + + } + + @Override + public boolean upgradeVmDb(long vmId, long serviceOfferingId) { + // TODO Auto-generated method stub + return false; + } + + @Override + public NicProfile addVmToNetwork(VirtualMachine vm, Network network, + NicProfile requested) throws ConcurrentOperationException, + ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean removeNicFromVm(VirtualMachine vm, NicVO nic) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean removeVmFromNetwork(VirtualMachine vm, Network network, + URI broadcastUri) throws ConcurrentOperationException, + ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public NicTO toNicTO(NicProfile nic, HypervisorType hypervisorType) { + // TODO Auto-generated method stub + return null; + } + + @Override + public VirtualMachineTO toVmTO( + VirtualMachineProfile<? extends VMInstanceVO> profile) { + // TODO Auto-generated method stub + return null; + } + + @Override + public VMInstanceVO reConfigureVm(VMInstanceVO vm, + ServiceOffering newServiceOffering, boolean sameHost) + throws ResourceUnavailableException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + @Override + public VMInstanceVO findHostAndMigrate(Type vmType, VMInstanceVO vm, + Long newSvcOfferingId) throws InsufficientCapacityException, + ConcurrentOperationException, ResourceUnavailableException, + VirtualMachineMigrationException, ManagementServerException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T migrateForScale(T vm, long srcHostId, + DeployDestination dest, Long newSvcOfferingId) + throws ResourceUnavailableException, ConcurrentOperationException, + ManagementServerException, VirtualMachineMigrationException { + // TODO Auto-generated method stub + return null; + } + + @Override + public <T extends VMInstanceVO> T processVmStartWork(T vm, Map<VirtualMachineProfile.Param, Object> params, User caller, Account account, DeploymentPlan planToDeploy) + throws InsufficientCapacityException, ConcurrentOperationException, ResourceUnavailableException { + + try { + Thread.sleep(120000); + } catch (InterruptedException e) { + } + + return vm; + } + + int wakeupCount = 0; + public void processVmStartWakeup() { + s_logger.info("processVmStartWakeup. job-" + AsyncJobExecutionContext.getCurrentExecutionContext().getJob().getId()); + + if(wakeupCount++ < 3) { + AsyncJobExecutionContext.getCurrentExecutionContext().resetSyncSource(); + } else { + AsyncJobExecutionContext.getCurrentExecutionContext().completeAsyncJob(AsyncJobConstants.STATUS_SUCCEEDED, 0, null); + } + } + + @Override - public <T extends VMInstanceVO> boolean processVmStopWork(T vm, boolean forced, User user, Account account) ++ public <T extends VMInstanceVO> boolean processVmStopWork(T vm, boolean forced, User user, Account account) + throws AgentUnavailableException, OperationTimedoutException, ConcurrentOperationException { + return true; + } ++ ++ @Override ++ public <T extends VMInstanceVO> T migrateWithStorage(T vm, long srcId, long destId, Map<VolumeVO, StoragePoolVO> volumeToPool) throws ResourceUnavailableException, ++ ConcurrentOperationException, ManagementServerException, VirtualMachineMigrationException { ++ // TODO Auto-generated method stub ++ return null; ++ } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d4039743/setup/db/db/schema-410to420.sql ---------------------------------------------------------------------- diff --cc setup/db/db/schema-410to420.sql index 16f93b2,065b35c..75eec59 --- a/setup/db/db/schema-410to420.sql +++ b/setup/db/db/schema-410to420.sql @@@ -391,83 -1116,65 +1116,132 @@@ CREATE VIEW `cloud`.`account_view` A and async_job.instance_type = 'Account' and async_job.job_status = 0; - ALTER TABLE `cloud`.`remote_access_vpn` ADD COLUMN `id` bigint unsigned NOT NULL UNIQUE AUTO_INCREMENT COMMENT 'id'; - ALTER TABLE `cloud`.`remote_access_vpn` ADD COLUMN `uuid` varchar(40) UNIQUE; - -- START: support for LXC - + - INSERT IGNORE INTO `cloud`.`hypervisor_capabilities`(hypervisor_type, hypervisor_version, max_guests_limit, security_group_enabled) VALUES ('LXC', 'default', 50, 1); - ALTER TABLE `cloud`.`physical_network_traffic_types` ADD COLUMN `lxc_network_label` varchar(255) DEFAULT 'cloudbr0' COMMENT 'The network name label of the physical device dedicated to this traffic on a LXC host'; + ALTER TABLE `cloud`.`load_balancing_rules` ADD COLUMN `source_ip_address` varchar(40) COMMENT 'source ip address for the load balancer rule'; + ALTER TABLE `cloud`.`load_balancing_rules` ADD COLUMN `source_ip_address_network_id` bigint unsigned COMMENT 'the id of the network where source ip belongs to'; + ALTER TABLE `cloud`.`load_balancing_rules` ADD COLUMN `scheme` varchar(40) NOT NULL COMMENT 'load balancer scheme; can be Internal or Public'; + UPDATE `cloud`.`load_balancing_rules` SET `scheme`='Public'; + - UPDATE configuration SET value='KVM,XenServer,VMware,BareMetal,Ovm,LXC' WHERE name='hypervisor.list'; + - INSERT INTO `cloud`.`vm_template` (id, unique_name, name, public, created, type, hvm, bits, account_id, url, checksum, enable_password, display_text, format, guest_os_id, featured, cross_zones, hypervisor_type) - VALUES (10, 'routing-10', 'SystemVM Template (LXC)', 0, now(), 'SYSTEM', 0, 64, 1, 'http://download.cloud.com/templates/acton/acton-systemvm-02062012.qcow2.bz2', '2755de1f9ef2ce4d6f2bee2efbb4da92', 0, 'SystemVM Template (LXC)', 'QCOW2', 15, 0, 1, 'LXC'); + +-- END: support for LXC + +ALTER TABLE `cloud`.`async_job` DROP COLUMN `session_key`; +ALTER TABLE `cloud`.`async_job` DROP COLUMN `job_cmd_originator`; +ALTER TABLE `cloud`.`async_job` DROP COLUMN `callback_type`; +ALTER TABLE `cloud`.`async_job` DROP COLUMN `callback_address`; + +ALTER TABLE `cloud`.`async_job` ADD COLUMN `job_type` VARCHAR(32); +ALTER TABLE `cloud`.`async_job` ADD COLUMN `job_dispatcher` VARCHAR(64); +ALTER TABLE `cloud`.`async_job` ADD COLUMN `job_executing_msid` bigint; +ALTER TABLE `cloud`.`async_job` ADD COLUMN `job_pending_signals` int(10) NOT NULL DEFAULT 0; +ALTER TABLE `cloud`.`vm_instance` ADD COLUMN `power_state` VARCHAR(74) DEFAULT 'PowerUnknown'; +ALTER TABLE `cloud`.`vm_instance` ADD COLUMN `power_state_update_time` DATETIME; +ALTER TABLE `cloud`.`vm_instance` ADD COLUMN `power_state_update_count` INT DEFAULT 0; +ALTER TABLE `cloud`.`vm_instance` ADD COLUMN `power_host` bigint unsigned; +ALTER TABLE `cloud`.`vm_instance` ADD CONSTRAINT `fk_vm_instance__power_host` FOREIGN KEY (`power_host`) REFERENCES `cloud`.`host`(`id`); +CREATE TABLE `cloud`.`vm_work_job` ( + `id` bigint unsigned UNIQUE NOT NULL, + `step` char(32) NOT NULL COMMENT 'state', + `vm_type` char(32) NOT NULL COMMENT 'type of vm', + `vm_instance_id` bigint unsigned NOT NULL COMMENT 'vm instance', + PRIMARY KEY (`id`), + CONSTRAINT `fk_vm_work_job__instance_id` FOREIGN KEY (`vm_instance_id`) REFERENCES `vm_instance`(`id`) ON DELETE CASCADE, + INDEX `i_vm_work_job__vm`(`vm_type`, `vm_instance_id`), + INDEX `i_vm_work_job__step`(`step`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8; + +CREATE TABLE `cloud`.`async_job_journal` ( + `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT 'id', + `job_id` bigint unsigned NOT NULL, + `journal_type` varchar(32), + `journal_text` varchar(1024) COMMENT 'journal descriptive informaton', + `journal_obj` varchar(1024) COMMENT 'journal strutural information, JSON encoded object', + `created` datetime NOT NULL COMMENT 'date created', + PRIMARY KEY (`id`), + CONSTRAINT `fk_async_job_journal__job_id` FOREIGN KEY (`job_id`) REFERENCES `async_job`(`id`) ON DELETE CASCADE +) ENGINE=InnoDB DEFAULT CHARSET=utf8; + +CREATE TABLE `cloud`.`async_job_join_map` ( + `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT 'id', + `job_id` bigint unsigned NOT NULL, + `join_job_id` bigint unsigned NOT NULL, + `join_status` int NOT NULL, + `join_result` varchar(1024), + `join_msid` bigint, + `complete_msid` bigint, + `sync_source_id` bigint COMMENT 'upper-level job sync source info before join', + `wakeup_handler` varchar(64), + `wakeup_dispatcher` varchar(64), + `wakeup_interval` bigint NOT NULL DEFAULT 3000 COMMENT 'wakeup interval in seconds', + `created` datetime NOT NULL, + `last_updated` datetime, + `next_wakeup` datetime, + `expiration` datetime, + PRIMARY KEY (`id`), + CONSTRAINT `fk_async_job_join_map__job_id` FOREIGN KEY (`job_id`) REFERENCES `async_job`(`id`) ON DELETE CASCADE, + CONSTRAINT `fk_async_job_join_map__join_job_id` FOREIGN KEY (`join_job_id`) REFERENCES `async_job`(`id`), + CONSTRAINT `fk_async_job_join_map__join` UNIQUE (`job_id`, `join_job_id`), + INDEX `i_async_job_join_map__join_job_id`(`join_job_id`), + INDEX `i_async_job_join_map__created`(`created`), + INDEX `i_async_job_join_map__last_updated`(`last_updated`), + INDEX `i_async_job_join_map__next_wakeup`(`next_wakeup`), + INDEX `i_async_job_join_map__expiration`(`expiration`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8; + -- Add details talbe for the network offering + CREATE TABLE `cloud`.`network_offering_details` ( + `id` bigint unsigned NOT NULL auto_increment, + `network_offering_id` bigint unsigned NOT NULL COMMENT 'network offering id', + `name` varchar(255) NOT NULL, + `value` varchar(1024) NOT NULL, + PRIMARY KEY (`id`), + CONSTRAINT `fk_network_offering_details__network_offering_id` FOREIGN KEY `fk_network_offering_details__network_offering_id`(`network_offering_id`) REFERENCES `network_offerings`(`id`) ON DELETE CASCADE + ) ENGINE=InnoDB DEFAULT CHARSET=utf8; + + -- Change the constraint for the network service map table. Now we support multiple provider for the same service + ALTER TABLE `cloud`.`ntwk_service_map` DROP FOREIGN KEY `fk_ntwk_service_map__network_id`; + ALTER TABLE `cloud`.`ntwk_service_map` DROP INDEX `network_id`; + + ALTER TABLE `cloud`.`ntwk_service_map` ADD UNIQUE `network_id` (`network_id`,`service`,`provider`); + ALTER TABLE `cloud`.`ntwk_service_map` ADD CONSTRAINT `fk_ntwk_service_map__network_id` FOREIGN KEY (`network_id`) REFERENCES `networks` (`id`) ON DELETE CASCADE; + + + ALTER TABLE `cloud`.`network_offerings` ADD COLUMN `internal_lb` int(1) unsigned NOT NULL DEFAULT '0' COMMENT 'true if the network offering supports Internal lb service'; + ALTER TABLE `cloud`.`network_offerings` ADD COLUMN `public_lb` int(1) unsigned NOT NULL DEFAULT '0' COMMENT 'true if the network offering supports Public lb service'; + UPDATE `cloud`.`network_offerings` SET public_lb=1 where id IN (SELECT DISTINCT network_offering_id FROM `cloud`.`ntwk_offering_service_map` WHERE service='Lb'); + + + INSERT IGNORE INTO `cloud`.`configuration` VALUES ('Advanced', 'DEFAULT', 'NetworkManager', 'internallbvm.service.offering', null, 'Uuid of the service offering used by internal lb vm; if NULL - default system internal lb offering will be used'); + + + alter table `cloud_usage`.`usage_network_offering` add column nic_id bigint(20) unsigned NOT NULL; + ALTER TABLE `cloud`.`data_center_details` MODIFY value varchar(1024); + ALTER TABLE `cloud`.`cluster_details` MODIFY value varchar(255); + ALTER TABLE `cloud`.`storage_pool_details` MODIFY value varchar(255); + ALTER TABLE `cloud`.`account_details` MODIFY value varchar(255); + + INSERT IGNORE INTO `cloud`.`configuration` VALUES ('Network', 'DEFAULT', 'management-server', 'midonet.apiserver.address', 'http://localhost:8081', 'Specify the address at which the Midonet API server can be contacted (if using Midonet)'); + INSERT IGNORE INTO `cloud`.`configuration` VALUES ('Network', 'DEFAULT', 'management-server', 'midonet.providerrouter.id', 'd7c5e6a3-e2f4-426b-b728-b7ce6a0448e5', 'Specifies the UUID of the Midonet provider router (if using Midonet)'); + + alter table cloud.vpc_gateways add column source_nat boolean default false; + alter table cloud.private_ip_address add column source_nat boolean default false; + + CREATE TABLE `cloud`.`account_vnet_map` ( + `id` bigint unsigned NOT NULL UNIQUE AUTO_INCREMENT, + `uuid` varchar(255) UNIQUE, + `vnet_range` varchar(255) NOT NULL COMMENT 'dedicated guest vlan range', + `account_id` bigint unsigned NOT NULL COMMENT 'account id. foreign key to account table', + `physical_network_id` bigint unsigned NOT NULL COMMENT 'physical network id. foreign key to the the physical network table', + PRIMARY KEY (`id`), + CONSTRAINT `fk_account_vnet_map__physical_network_id` FOREIGN KEY (`physical_network_id`) REFERENCES `physical_network` (`id`) ON DELETE CASCADE, + INDEX `i_account_vnet_map__physical_network_id`(`physical_network_id`), + CONSTRAINT `fk_account_vnet_map__account_id` FOREIGN KEY (`account_id`) REFERENCES `account` (`id`) ON DELETE CASCADE, + INDEX `i_account_vnet_map__account_id`(`account_id`) + ) ENGINE=InnoDB DEFAULT CHARSET=utf8; + + ALTER TABLE `cloud`.`op_dc_vnet_alloc` ADD COLUMN account_vnet_map_id bigint unsigned; + ALTER TABLE `cloud`.`op_dc_vnet_alloc` ADD CONSTRAINT `fk_op_dc_vnet_alloc__account_vnet_map_id` FOREIGN KEY `fk_op_dc_vnet_alloc__account_vnet_map_id` (`account_vnet_map_id`) REFERENCES `account_vnet_map` (`id`);
