Java VirtualMachineProfileImpl类代码示例

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkWhenDcInAvoidList() throws InsufficientServerCapacityException {
    final Zone zone = mock(Zone.class);
    final ExcludeList avoids = mock(ExcludeList.class);
    final VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    final VMInstanceVO vm = mock(VMInstanceVO.class);
    final DataCenterDeployment plan = mock(DataCenterDeployment.class);

    when(avoids.shouldAvoid(zone)).thenReturn(true);
    when(vmProfile.getVirtualMachine()).thenReturn(vm);
    when(vm.getDataCenterId()).thenReturn(1L);
    when(zoneRepository.findOne(1L)).thenReturn(zone);

    final List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);
    assertTrue("Cluster list should be null/empty if the dc is in avoid list", (clusterList == null || clusterList.isEmpty()));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkStrictModeNoHostsAvailable() throws InsufficientServerCapacityException {
    final VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    final DataCenterDeployment plan = mock(DataCenterDeployment.class);
    final ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    // Mark the host 5 and 6 to be in avoid list.
    avoids.addHost(5L);
    avoids.addHost(6L);
    final List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster list is empty.
    assertTrue("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkPreferredModeNoHostsAvailable() throws InsufficientServerCapacityException {
    final VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    final DataCenterDeployment plan = mock(DataCenterDeployment.class);
    final ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    // Mark the host 5, 6 and 7 to be in avoid list.
    avoids.addHost(5L);
    avoids.addHost(6L);
    avoids.addHost(7L);
    final List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster list is empty.
    assertTrue("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkWhenDcInAvoidList() throws InsufficientServerCapacityException {
    DataCenterVO mockDc = mock(DataCenterVO.class);
    ExcludeList avoids = mock(ExcludeList.class);
    VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    VMInstanceVO vm = mock(VMInstanceVO.class);
    DataCenterDeployment plan = mock(DataCenterDeployment.class);

    when(avoids.shouldAvoid(mockDc)).thenReturn(true);
    when(vmProfile.getVirtualMachine()).thenReturn(vm);
    when(vm.getDataCenterId()).thenReturn(1L);
    when(dcDao.findById(1L)).thenReturn(mockDc);

    List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);
    assertTrue("Cluster list should be null/empty if the dc is in avoid list", (clusterList == null || clusterList.isEmpty()));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkStrictModeNoHostsAvailable() throws InsufficientServerCapacityException {
    @SuppressWarnings("unchecked")
    VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    DataCenterDeployment plan = mock(DataCenterDeployment.class);
    ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    // Mark the host 5 and 6 to be in avoid list.
    avoids.addHost(5L);
    avoids.addHost(6L);
    List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster list is empty.
    assertTrue("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkPreferredModeNoHostsAvailable() throws InsufficientServerCapacityException {
    @SuppressWarnings("unchecked")
    VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    DataCenterDeployment plan = mock(DataCenterDeployment.class);
    ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    // Mark the host 5, 6 and 7 to be in avoid list.
    avoids.addHost(5L);
    avoids.addHost(6L);
    avoids.addHost(7L);
    List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster list is empty.
    assertTrue("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Override
public StoragePool findStoragePool(final DiskProfile dskCh, final DataCenter dc, final Pod pod, final Long clusterId, final Long hostId, final VirtualMachine vm, final
Set<StoragePool> avoid) {
    Long podId = null;
    if (pod != null) {
        podId = pod.getId();
    } else if (clusterId != null) {
        final Cluster cluster = _entityMgr.findById(Cluster.class, clusterId);
        if (cluster != null) {
            podId = cluster.getPodId();
        }
    }

    final VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
    for (final StoragePoolAllocator allocator : _storagePoolAllocators) {

        final ExcludeList avoidList = new ExcludeList();
        for (final StoragePool pool : avoid) {
            avoidList.addPool(pool.getId());
        }
        final DataCenterDeployment plan = new DataCenterDeployment(dc.getId(), podId, clusterId, hostId, null, null);

        final List<StoragePool> poolList = allocator.allocateToPool(dskCh, profile, plan, avoidList, 1);
        if (poolList != null && !poolList.isEmpty()) {
            return (StoragePool) dataStoreMgr.getDataStore(poolList.get(0).getId(), DataStoreRole.Primary);
        }
    }
    return null;
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkStrictModeWithCurrentAccountVmsPresent() throws InsufficientServerCapacityException {
    final VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    final DataCenterDeployment plan = mock(DataCenterDeployment.class);
    final ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    final List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster 2 and 3 are not in the cluster list.
    // Host 6 and 7 should also be in avoid list.
    assertFalse("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
    boolean foundNeededCluster = false;
    for (final Long cluster : clusterList) {
        if (cluster != 1) {
            fail("Found a cluster that shouldn't have been present, cluster id : " + cluster);
        } else {
            foundNeededCluster = true;
        }
    }
    assertTrue("Didn't find cluster 1 in the list. It should have been present", foundNeededCluster);

    final Set<Long> hostsInAvoidList = avoids.getHostsToAvoid();
    assertFalse("Host 5 shouldn't have be in the avoid list, but it is present", hostsInAvoidList.contains(5L));
    final Set<Long> hostsThatShouldBeInAvoidList = new HashSet<>();
    hostsThatShouldBeInAvoidList.add(6L);
    hostsThatShouldBeInAvoidList.add(7L);
    assertTrue("Hosts 6 and 7 that should have been present were not found in avoid list", hostsInAvoidList.containsAll(hostsThatShouldBeInAvoidList));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkStrictModeHostWithCurrentAccountVmsFull() throws InsufficientServerCapacityException {
    final VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    final DataCenterDeployment plan = mock(DataCenterDeployment.class);
    final ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    // Mark the host 5 with current account vms to be in avoid list.
    avoids.addHost(5L);
    final List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster 1 and 3 are not in the cluster list.
    // Host 5 and 7 should also be in avoid list.
    assertFalse("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
    boolean foundNeededCluster = false;
    for (final Long cluster : clusterList) {
        if (cluster != 2) {
            fail("Found a cluster that shouldn't have been present, cluster id : " + cluster);
        } else {
            foundNeededCluster = true;
        }
    }
    assertTrue("Didn't find cluster 2 in the list. It should have been present", foundNeededCluster);

    final Set<Long> hostsInAvoidList = avoids.getHostsToAvoid();
    assertFalse("Host 6 shouldn't have be in the avoid list, but it is present", hostsInAvoidList.contains(6L));
    final Set<Long> hostsThatShouldBeInAvoidList = new HashSet<>();
    hostsThatShouldBeInAvoidList.add(5L);
    hostsThatShouldBeInAvoidList.add(7L);
    assertTrue("Hosts 5 and 7 that should have been present were not found in avoid list", hostsInAvoidList.containsAll(hostsThatShouldBeInAvoidList));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkPreferredModePreferredHostAvailable() throws InsufficientServerCapacityException {
    final VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    final DataCenterDeployment plan = mock(DataCenterDeployment.class);
    final ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(true);

    // Mark the host 5 and 6 to be in avoid list.
    avoids.addHost(5L);
    avoids.addHost(6L);
    final List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster 1 and 2 are not in the cluster list.
    // Host 5 and 6 should also be in avoid list.
    assertFalse("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
    boolean foundNeededCluster = false;
    for (final Long cluster : clusterList) {
        if (cluster != 3) {
            fail("Found a cluster that shouldn't have been present, cluster id : " + cluster);
        } else {
            foundNeededCluster = true;
        }
    }
    assertTrue("Didn't find cluster 3 in the list. It should have been present", foundNeededCluster);

    final Set<Long> hostsInAvoidList = avoids.getHostsToAvoid();
    assertFalse("Host 7 shouldn't have be in the avoid list, but it is present", hostsInAvoidList.contains(7L));
    final Set<Long> hostsThatShouldBeInAvoidList = new HashSet<>();
    hostsThatShouldBeInAvoidList.add(5L);
    hostsThatShouldBeInAvoidList.add(6L);
    assertTrue("Hosts 5 and 6 that should have been present were not found in avoid list", hostsInAvoidList.containsAll(hostsThatShouldBeInAvoidList));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void finalizeDeploymentTest() throws ResourceUnavailableException {
    ReservationContext context = Mockito.mock(ReservationContext.class);
    Commands cmds = Mockito.mock(Commands.class);
    DataCenter dc = Mockito.mock(DataCenter.class);

    VirtualMachineProfileImpl profile = Mockito.mock(VirtualMachineProfileImpl.class);
    Mockito.when(profile.getNics()).thenReturn(new ArrayList<NicProfile>());
    Mockito.when(profile.getId()).thenReturn(0l);

    AutonomiccsSystemVm autonomiccsSystemVm = Mockito.mock(AutonomiccsSystemVm.class);
    Mockito.doReturn(autonomiccsSystemVm).when(autonomiccsSystemVmDao).findById(Mockito.anyLong());

    DeployDestination dest = Mockito.mock(DeployDestination.class);
    Mockito.when(dest.getDataCenter()).thenReturn(dc);

    Mockito.doNothing().when(spy).setIpAddressOfEachNic(Mockito.any(AutonomiccsSystemVm.class), Mockito.any(DataCenter.class), Matchers.anyListOf(NicProfile.class));
    Mockito.doReturn(true).when(autonomiccsSystemVmDao).update(Mockito.anyLong(), Mockito.any(AutonomiccsSystemVm.class));

    boolean result = spy.finalizeDeployment(cmds, profile, dest, context);
    Assert.assertEquals(true, result);

    InOrder inOrder = Mockito.inOrder(autonomiccsSystemVmDao, spy);
    inOrder.verify(autonomiccsSystemVmDao).findById(Mockito.anyLong());
    inOrder.verify(spy).setIpAddressOfEachNic(Mockito.any(AutonomiccsSystemVm.class), Mockito.any(DataCenter.class), Matchers.anyListOf(NicProfile.class));
    inOrder.verify(autonomiccsSystemVmDao).update(Mockito.anyLong(), Mockito.any(AutonomiccsSystemVm.class));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Override
public StoragePool findStoragePool(DiskProfile dskCh, DataCenter dc, Pod pod, Long clusterId, Long hostId, VirtualMachine vm, final Set<StoragePool> avoid) {
    Long podId = null;
    if (pod != null) {
        podId = pod.getId();
    } else if (clusterId != null) {
        Cluster cluster = _entityMgr.findById(Cluster.class, clusterId);
        if (cluster != null) {
            podId = cluster.getPodId();
        }
    }

    VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm);
    for (StoragePoolAllocator allocator : _storagePoolAllocators) {

        ExcludeList avoidList = new ExcludeList();
        for (StoragePool pool : avoid) {
            avoidList.addPool(pool.getId());
        }
        DataCenterDeployment plan = new DataCenterDeployment(dc.getId(), podId, clusterId, hostId, null, null);

        final List<StoragePool> poolList = allocator.allocateToPool(dskCh, profile, plan, avoidList, 1);
        if (poolList != null && !poolList.isEmpty()) {
            return (StoragePool)dataStoreMgr.getDataStore(poolList.get(0).getId(), DataStoreRole.Primary);
        }
    }
    return null;
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void testRelease() {
    final Answer answer = mock(Answer.class);
    when(endpoint.sendMessage(any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
    when(answer.getResult()).thenReturn(true);
    VirtualMachineProfile profile = new VirtualMachineProfileImpl(virtualMachine, null, serviceOfferingVO, null, null);
    assertTrue(_configDrivesNetworkElement.release(network, nicp, profile, null));
}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void testAddPasswordAndUserdata() throws InsufficientCapacityException, ResourceUnavailableException {
    final Answer answer = mock(Answer.class);
    final UserVmDetailVO userVmDetailVO = mock(UserVmDetailVO.class);
    when(endpoint.sendMessage(any(HandleConfigDriveIsoCommand.class))).thenReturn(answer);
    when(answer.getResult()).thenReturn(true);
    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Guest);
    when(virtualMachine.getState()).thenReturn(VirtualMachine.State.Stopped);
    when(userVmDetailVO.getValue()).thenReturn(PUBLIC_KEY);
    when(_userVmDetailsDao.findDetail(anyLong(), anyString())).thenReturn(userVmDetailVO);
    Map<VirtualMachineProfile.Param, Object> parms = Maps.newHashMap();
    parms.put(VirtualMachineProfile.Param.VmPassword, PASSWORD);
    parms.put(VirtualMachineProfile.Param.VmSshPubKey, PUBLIC_KEY);
    VirtualMachineProfile profile = new VirtualMachineProfileImpl(virtualMachine, null, serviceOfferingVO, null, parms);
    assertTrue(_configDrivesNetworkElement.addPasswordAndUserdata(
            network, nicp, profile, deployDestination, null));

    ArgumentCaptor<HandleConfigDriveIsoCommand> commandCaptor = ArgumentCaptor.forClass(HandleConfigDriveIsoCommand.class);
    verify(endpoint, times(1)).sendMessage(commandCaptor.capture());
    HandleConfigDriveIsoCommand result = commandCaptor.getValue();
    List<String[]> actualVmData = result.getVmData();

    assertThat(actualVmData, containsInAnyOrder(
            new String[]{"userdata", "user_data", VMUSERDATA},
            new String[]{"metadata", "service-offering", VMOFFERING},
            new String[]{"metadata", "availability-zone", ZONENAME},
            new String[]{"metadata", "local-hostname", VMINSTANCENAME},
            new String[]{"metadata", "vm-id", String.valueOf(VMID)},
            new String[]{"metadata", "instance-id", String.valueOf(VMINSTANCENAME)},
            new String[]{"metadata", "public-keys", PUBLIC_KEY},
            new String[]{"metadata", "cloud-identifier", String.format("CloudStack-{%s}", CLOUD_ID)},
            new String[]{PASSWORD, "vm_password", PASSWORD}
    ));

}
 

import com.cloud.vm.VirtualMachineProfileImpl; //导入依赖的package包/类
@Test
public void checkStrictModeWithCurrentAccountVmsPresent() throws InsufficientServerCapacityException {
    VirtualMachineProfileImpl vmProfile = mock(VirtualMachineProfileImpl.class);
    DataCenterDeployment plan = mock(DataCenterDeployment.class);
    ExcludeList avoids = new ExcludeList();

    initializeForTest(vmProfile, plan);

    initializeForImplicitPlannerTest(false);

    List<Long> clusterList = planner.orderClusters(vmProfile, plan, avoids);

    // Validations.
    // Check cluster 2 and 3 are not in the cluster list.
    // Host 6 and 7 should also be in avoid list.
    assertFalse("Cluster list should not be null/empty", (clusterList == null || clusterList.isEmpty()));
    boolean foundNeededCluster = false;
    for (Long cluster : clusterList) {
        if (cluster != 1) {
            fail("Found a cluster that shouldn't have been present, cluster id : " + cluster);
        } else {
            foundNeededCluster = true;
        }
    }
    assertTrue("Didn't find cluster 1 in the list. It should have been present", foundNeededCluster);

    Set<Long> hostsInAvoidList = avoids.getHostsToAvoid();
    assertFalse("Host 5 shouldn't have be in the avoid list, but it is present", hostsInAvoidList.contains(5L));
    Set<Long> hostsThatShouldBeInAvoidList = new HashSet<Long>();
    hostsThatShouldBeInAvoidList.add(6L);
    hostsThatShouldBeInAvoidList.add(7L);
    assertTrue("Hosts 6 and 7 that should have been present were not found in avoid list", hostsInAvoidList.containsAll(hostsThatShouldBeInAvoidList));
}