You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by ah...@apache.org on 2013/05/14 02:43:07 UTC
[44/50] [abbrv] Merged master to vmsync
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`);