apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '4.20' of https://github.com/apache/cloudstack

Browse Source
This commit is contained in:
Pearl Dsilva 2025-05-22 12:05:47 +05:30
commit f496ed6eaf
10 changed files with 179 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/src/main/java/org/apache/cloudstack/api/ApiConstants.java
View File

@ -456,6 +456,7 @@ public class ApiConstants {
public static final String SENT = "sent";
public static final String SENT_BYTES = "sentbytes";
public static final String SERIAL = "serial";
public static final String SERVICE_IP = "serviceip";
public static final String SERVICE_OFFERING_ID = "serviceofferingid";
public static final String SESSIONKEY = "sessionkey";
public static final String SHOW_CAPACITIES = "showcapacities";

13
api/src/main/java/org/apache/cloudstack/api/response/ManagementServerResponse.java
View File

@ -74,6 +74,11 @@ public class ManagementServerResponse extends BaseResponse {
@Param(description = "the running OS kernel version for this Management Server")
private String kernelVersion;
@Deprecated
@SerializedName(ApiConstants.SERVICE_IP)
@Param(description = "the IP Address for this Management Server. This is deprecated, please use 'ipaddress' instead.")
private String serviceIp;
@SerializedName(ApiConstants.IP_ADDRESS)
@Param(description = "the IP Address for this Management Server")
private String ipAddress;
@ -138,6 +143,10 @@ public class ManagementServerResponse extends BaseResponse {
return lastBoot;
}
public String getServiceIp() {
return serviceIp;
}
public String getIpAddress() {
return ipAddress;
}
@ -202,6 +211,10 @@ public class ManagementServerResponse extends BaseResponse {
this.kernelVersion = kernelVersion;
}
public void setServiceIp(String serviceIp) {
this.serviceIp = serviceIp;
}
public void setIpAddress(String ipAddress) {
this.ipAddress = ipAddress;
}

14
plugins/hypervisors/vmware/src/main/java/com/cloud/hypervisor/vmware/manager/VmwareManagerImpl.java
View File

@ -253,7 +253,7 @@ public class VmwareManagerImpl extends ManagerBase implements VmwareManager, Vmw
private boolean _fullCloneFlag;
private boolean _instanceNameFlag;
private String _serviceConsoleName;
private String _managemetPortGroupName;
private String _managementPortGroupName;
private String _defaultSystemVmNicAdapterType = VirtualEthernetCardType.E1000.toString();
private String _recycleHungWorker = "false";
private int _additionalPortRangeStart;
@ -351,9 +351,9 @@ public class VmwareManagerImpl extends ManagerBase implements VmwareManager, Vmw
_serviceConsoleName = "Service Console";
}
_managemetPortGroupName = _configDao.getValue(Config.VmwareManagementPortGroup.key());
if (_managemetPortGroupName == null) {
_managemetPortGroupName = "Management Network";
_managementPortGroupName = _configDao.getValue(Config.VmwareManagementPortGroup.key());
if (_managementPortGroupName == null) {
_managementPortGroupName = "Management Network";
}
_defaultSystemVmNicAdapterType = _configDao.getValue(Config.VmwareSystemVmNicDeviceType.key());
@ -618,13 +618,13 @@ public class VmwareManagerImpl extends ManagerBase implements VmwareManager, Vmw
@Override
public String getManagementPortGroupName() {
return _managemetPortGroupName;
return _managementPortGroupName;
}
@Override
public String getManagementPortGroupByHost(HostMO hostMo) throws Exception {
if (hostMo.getHostType() == VmwareHostType.ESXi) {
return _managemetPortGroupName;
return _managementPortGroupName;
}
return _serviceConsoleName;
}
@ -634,7 +634,7 @@ public class VmwareManagerImpl extends ManagerBase implements VmwareManager, Vmw
params.put("vmware.create.full.clone", _fullCloneFlag);
params.put("vm.instancename.flag", _instanceNameFlag);
params.put("service.console.name", _serviceConsoleName);
params.put("management.portgroup.name", _managemetPortGroupName);
params.put("management.portgroup.name", _managementPortGroupName);
params.put("vmware.root.disk.controller", _rootDiskController);
params.put("vmware.data.disk.controller", _dataDiskController);
params.put("vmware.recycle.hung.wokervm", _recycleHungWorker);

1
server/src/main/java/com/cloud/api/query/QueryManagerImpl.java
View File

@ -5663,6 +5663,7 @@ public class QueryManagerImpl extends MutualExclusiveIdsManagerBase implements Q
mgmtResponse.setAgents(agents);
mgmtResponse.setAgentsCount((long) agents.size());
mgmtResponse.setPendingJobsCount(jobManager.countPendingNonPseudoJobs(mgmt.getMsid()));
mgmtResponse.setServiceIp(mgmt.getServiceIP());
mgmtResponse.setIpAddress(mgmt.getServiceIP());
mgmtResponse.setObjectName("managementserver");
return mgmtResponse;

2
server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java
View File

@ -4893,7 +4893,7 @@ public class ConfigurationManagerImpl extends ManagerBase implements Configurati
final String cidrnew = NetUtils.getCidrFromGatewayAndNetmask(newVlanGateway, newVlanNetmask);
final String existing_cidr = NetUtils.getCidrFromGatewayAndNetmask(vlanGateway, vlanNetmask);
return NetUtils.isNetowrkASubsetOrSupersetOfNetworkB(cidrnew, existing_cidr);
return NetUtils.isNetworkASubsetOrSupersetOfNetworkB(cidrnew, existing_cidr);
}
public Pair<Boolean, Pair<String, String>> validateIpRange(final String startIP, final String endIP, final String newVlanGateway, final String newVlanNetmask, final List<VlanVO> vlans, final boolean ipv4,

146
server/src/main/java/com/cloud/vm/UserVmManagerImpl.java
View File

@ -55,6 +55,7 @@ import javax.naming.ConfigurationException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import com.cloud.network.NetworkService;
import org.apache.cloudstack.acl.ControlledEntity;
import org.apache.cloudstack.acl.ControlledEntity.ACLType;
import org.apache.cloudstack.acl.SecurityChecker.AccessType;
@ -606,6 +607,9 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
@Inject
NsxProviderDao nsxProviderDao;
@Inject
NetworkService networkService;
private ScheduledExecutorService _executor = null;
private ScheduledExecutorService _vmIpFetchExecutor = null;
@ -7495,12 +7499,21 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
logger.trace("Verifying if the new account [{}] has access to the specified domain [{}].", newAccount, domain);
_accountMgr.checkAccess(newAccount, domain);
Transaction.execute(new TransactionCallbackNoReturn() {
@Override
public void doInTransactionWithoutResult(TransactionStatus status) {
executeStepsToChangeOwnershipOfVm(cmd, caller, oldAccount, newAccount, vm, offering, volumes, template, domainId);
Network newNetwork = ensureDestinationNetwork(cmd, vm, newAccount);
try {
Transaction.execute(new TransactionCallbackNoReturn() {
@Override
public void doInTransactionWithoutResult(TransactionStatus status) {
executeStepsToChangeOwnershipOfVm(cmd, caller, oldAccount, newAccount, vm, offering, volumes, template, domainId);
}
});
} catch (Exception e) {
if (newNetwork != null) {
logger.debug("Cleaning up the created network.");
networkService.deleteNetwork(newNetwork.getId(), false);
}
});
throw e;
}
logger.info("VM [{}] now belongs to account [{}].", vm.getInstanceName(), newAccountName);
return vm;
@ -7606,6 +7619,67 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
}
}
/**
* This method will create an isolated network for the new account to allocate the virtual machine if:
* <ul>
* <li>no networks were specified to the command, AND</li>
* <li>the zone uses advanced networks without security groups, AND</li>
* <li>the VM does not belong to any shared or L2 network that the new owner can access, AND</li>
* <li>the new owner does not have any isolated networks</li>
* </ul>
* @return the created isolated network, or null if it was not created.
*/
protected Network ensureDestinationNetwork(AssignVMCmd cmd, UserVmVO vm, Account newAccount) throws InsufficientCapacityException, ResourceAllocationException {
DataCenterVO zone = _dcDao.findById(vm.getDataCenterId());
if (zone.getNetworkType() == NetworkType.Basic) {
logger.debug("No need to ensure an isolated network for the VM because the zone uses basic networks.");
return null;
}
List<Long> networkIdList = cmd.getNetworkIds();
List<Long> securityGroupIdList = cmd.getSecurityGroupIdList();
if (_networkModel.checkSecurityGroupSupportForNetwork(newAccount, zone, networkIdList, securityGroupIdList)) {
logger.debug("No need to ensure an isolated network for the VM because security groups is enabled for this zone.");
return null;
}
if (CollectionUtils.isNotEmpty(securityGroupIdList)) {
throw new InvalidParameterValueException("Cannot move VM with security groups; security group feature is not enabled in this zone.");
}
LinkedHashSet<NetworkVO> applicableNetworks = new LinkedHashSet<>();
addNetworksToNetworkIdList(vm, newAccount, networkIdList, applicableNetworks, new HashMap<>(), new HashMap<>());
if (!applicableNetworks.isEmpty()) {
logger.debug("No need to create an isolated network for the VM because there are other applicable networks.");
return null;
}
List<? extends Network> virtualNetworks = _networkModel.listNetworksForAccount(newAccount.getId(), zone.getId(), Network.GuestType.Isolated);
if (!virtualNetworks.isEmpty()) {
logger.debug("No need create a new isolated network for the VM because the owner already has existing isolated networks.");
return null;
}
return createApplicableNetworkToCreateVm(newAccount, zone);
}
/**
* @return a network offering with required availability that will be used to create a new isolated network for the VM
* assignment process.
*/
protected NetworkOfferingVO getOfferingWithRequiredAvailabilityForNetworkCreation() {
List<NetworkOfferingVO> requiredOfferings = _networkOfferingDao.listByAvailability(Availability.Required, false);
if (CollectionUtils.isEmpty(requiredOfferings)) {
throw new InvalidParameterValueException(String.format("Unable to find network offering with availability [%s] to automatically create the network as a part of VM "
+ "creation.", Availability.Required));
}
NetworkOfferingVO firstRequiredOffering = requiredOfferings.get(0);
if (firstRequiredOffering.getState() != NetworkOffering.State.Enabled) {
throw new InvalidParameterValueException(String.format("Required network offering ID [%s] is not in [%s] state.", firstRequiredOffering.getId(),
NetworkOffering.State.Enabled));
}
return firstRequiredOffering;
}
/**
* Executes all ownership steps necessary to assign a VM to another user:
* generating a destroy VM event ({@link EventTypes}),
@ -7699,9 +7773,9 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
/**
* Updates the network for a VM being assigned to a new account.
* If the network type for the zone is basic, calls
* {@link #updateBasicTypeNetworkForVm(AssignVMCmd, UserVmVO, Account, VirtualMachineTemplate, VirtualMachineProfileImpl, DataCenterVO, List, List)}.
* {@link #updateBasicTypeNetworkForVm(UserVmVO, Account, VirtualMachineTemplate, VirtualMachineProfileImpl, DataCenterVO, List, List)}.
* If the network type for the zone is advanced, calls
* {@link #updateAdvancedTypeNetworkForVm(AssignVMCmd, Account, UserVmVO, Account, VirtualMachineTemplate, VirtualMachineProfileImpl, DataCenterVO, List, List)}.
* {@link #updateAdvancedTypeNetworkForVm(Account, UserVmVO, Account, VirtualMachineTemplate, VirtualMachineProfileImpl, DataCenterVO, List, List)}.
* @param cmd The assignVMCmd.
* @param caller The account calling the assignVMCmd.
* @param vm The VM to be assigned to another user, which has to have networks updated.
@ -7724,11 +7798,11 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
List<Long> securityGroupIdList = cmd.getSecurityGroupIdList();
if (zone.getNetworkType() == NetworkType.Basic) {
updateBasicTypeNetworkForVm(cmd, vm, newAccount, template, vmOldProfile, zone, networkIdList, securityGroupIdList);
updateBasicTypeNetworkForVm(vm, newAccount, template, vmOldProfile, zone, networkIdList, securityGroupIdList);
return;
}
updateAdvancedTypeNetworkForVm(cmd, caller, vm, newAccount, template, vmOldProfile, zone, networkIdList, securityGroupIdList);
updateAdvancedTypeNetworkForVm(caller, vm, newAccount, template, vmOldProfile, zone, networkIdList, securityGroupIdList);
}
/**
@ -7781,7 +7855,6 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* allocating all networks ({@link #allocateNetworksForVm(UserVmVO, LinkedHashMap)}),
* and adding security groups to the VM ({@link #addSecurityGroupsToVm(Account, UserVmVO, VirtualMachineTemplate, List, Network)}).
* If the network has network IDs, throws a {@link InvalidParameterValueException}.
* @param cmd The assignVMCmd which attempts to update a basic network.
* @param vm The VM for which the networks are allocated.
* @param newAccount The new account to which the VM will be assigned to.
* @param template The template of the VM.
@ -7791,7 +7864,7 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* @param securityGroupIdList The list of security groups provided to the assignVMCmd.
* @throws InsufficientCapacityException
*/
protected void updateBasicTypeNetworkForVm(AssignVMCmd cmd, UserVmVO vm, Account newAccount, VirtualMachineTemplate template, VirtualMachineProfileImpl vmOldProfile,
protected void updateBasicTypeNetworkForVm(UserVmVO vm, Account newAccount, VirtualMachineTemplate template, VirtualMachineProfileImpl vmOldProfile,
DataCenterVO zone, List<Long> networkIdList, List<Long> securityGroupIdList) throws InsufficientCapacityException {
if (networkIdList != null && !networkIdList.isEmpty()) {
@ -7821,11 +7894,10 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* Updates an advanced type network by:
* adding NICs to the networks ({@link #addNicsToApplicableNetworksAndReturnDefaultNetwork(LinkedHashSet, Map, Map, LinkedHashMap)}),
* allocating - if security groups are enabled ({@link #allocateNetworksForVm(UserVmVO, LinkedHashMap)}) -
* or selecting applicable networks otherwise ({@link #selectApplicableNetworkToCreateVm(Account, Account, DataCenterVO, Set)}),
* or selecting applicable networks otherwise ({@link #selectApplicableNetworkToCreateVm(Account, DataCenterVO, Set)}),
* and adding security groups to the VM ({@link #addSecurityGroupsToVm(Account, UserVmVO, VirtualMachineTemplate, List, Network)}) - if enabled in the zone.
* If no applicable network is provided and the zone has security groups enabled, throws a {@link InvalidParameterValueException}.
* If security groups are not enabled, but security groups have been provided, throws a {@link InvalidParameterValueException}.
* @param cmd The assignVMCmd which attempts to update an advanced network.
* @param caller The caller of the assignVMCmd.
* @param vm The VM for which the networks are allocated or selected.
* @param newAccount The new account to which the VM will be assigned to.
@ -7838,7 +7910,7 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* @throws ResourceAllocationException
* @throws InvalidParameterValueException
*/
protected void updateAdvancedTypeNetworkForVm(AssignVMCmd cmd, Account caller, UserVmVO vm, Account newAccount, VirtualMachineTemplate template,
protected void updateAdvancedTypeNetworkForVm(Account caller, UserVmVO vm, Account newAccount, VirtualMachineTemplate template,
VirtualMachineProfileImpl vmOldProfile, DataCenterVO zone, List<Long> networkIdList, List<Long> securityGroupIdList)
throws InsufficientCapacityException, ResourceAllocationException, InvalidParameterValueException {
@ -7851,7 +7923,8 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
logger.debug("Cleanup of old security groups for VM [{}]. They will be recreated for the new account once the VM is started.", vm);
_securityGroupMgr.removeInstanceFromGroups(vm);
addNetworksToNetworkIdList(vm, newAccount, vmOldProfile, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
addNetworksToNetworkIdList(vm, newAccount, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
cleanupOfOldOwnerNicsForNetwork(vmOldProfile);
NetworkVO defaultNetwork = addNicsToApplicableNetworksAndReturnDefaultNetwork(applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics, networks);
@ -7869,10 +7942,11 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
throw new InvalidParameterValueException("Cannot move VM with security groups; security group feature is not enabled in this zone.");
}
addNetworksToNetworkIdList(vm, newAccount, vmOldProfile, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
addNetworksToNetworkIdList(vm, newAccount, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
cleanupOfOldOwnerNicsForNetwork(vmOldProfile);
if (applicableNetworks.isEmpty()) {
selectApplicableNetworkToCreateVm(caller, newAccount, zone, applicableNetworks);
selectApplicableNetworkToCreateVm(newAccount, zone, applicableNetworks);
}
addNicsToApplicableNetworksAndReturnDefaultNetwork(applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics, networks);
@ -7928,16 +8002,14 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* Adds all networks to the list of network IDs by:
* attempting to keep the shared network for the VM ({@link #keepOldSharedNetworkForVm(UserVmVO, Account, List, Set, Map, Map)}),
* adding any additional applicable networks to the VM ({@link #addAdditionalNetworksToVm(UserVmVO, Account, List, Set, Map, Map)}),
* and cleaning up the network associated to the old owner ({@link #cleanupOfOldOwnerNicsForNetwork(VirtualMachineProfileImpl)}).
* @param vm The VM to add the networks to.
* @param newAccount The account to access the networks.
* @param vmOldProfile The old profile of the VM.
* @param networkIdList The network IDs which have to be added to the VM.
* @param applicableNetworks The applicable networks which have to be added to the VM.
* @param requestedIPv4ForNics All requested IPv4 for NICs.
* @param requestedIPv6ForNics All requested IPv6 for NICs.
*/
protected void addNetworksToNetworkIdList(UserVmVO vm, Account newAccount, VirtualMachineProfileImpl vmOldProfile, List<Long> networkIdList, Set<NetworkVO> applicableNetworks,
protected void addNetworksToNetworkIdList(UserVmVO vm, Account newAccount, List<Long> networkIdList, Set<NetworkVO> applicableNetworks,
Map<Long, String> requestedIPv4ForNics, Map<Long, String> requestedIPv6ForNics) {
logger.trace("Adding networks to network list.");
@ -7945,8 +8017,6 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
keepOldSharedNetworkForVm(vm, newAccount, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
addAdditionalNetworksToVm(vm, newAccount, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
cleanupOfOldOwnerNicsForNetwork(vmOldProfile);
}
/**
@ -7987,34 +8057,21 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* If the network offering applicable is not enabled, throws a {@link InvalidParameterValueException}.
* If more than one default isolated network is related to the account, throws a {@link InvalidParameterValueException}, since the ID of the network to be used has to be
* specified.
* @param caller The account which calls to select the applicable network.
* @param newAccount The new account associated to the selected network.
* @param zone The zone where the network is selected.
* @param applicableNetworks The applicable networks to which the selected network has to be added to.
* @throws InsufficientCapacityException
* @throws ResourceAllocationException
*/
protected void selectApplicableNetworkToCreateVm(Account caller, Account newAccount, DataCenterVO zone, Set<NetworkVO> applicableNetworks)
protected void selectApplicableNetworkToCreateVm(Account newAccount, DataCenterVO zone, Set<NetworkVO> applicableNetworks)
throws InsufficientCapacityException, ResourceAllocationException {
logger.trace("Selecting the applicable network to create the VM.");
List<NetworkOfferingVO> requiredOfferings = _networkOfferingDao.listByAvailability(Availability.Required, false);
if (CollectionUtils.isEmpty(requiredOfferings)) {
throw new InvalidParameterValueException(String.format("Unable to find network offering with availability [%s] to automatically create the network as a part of VM "
+ "creation.", Availability.Required));
}
NetworkOfferingVO firstRequiredOffering = requiredOfferings.get(0);
if (firstRequiredOffering.getState() != NetworkOffering.State.Enabled) {
throw new InvalidParameterValueException(String.format("Required network offering ID [%s] is not in [%s] state.", firstRequiredOffering.getId(),
NetworkOffering.State.Enabled));
}
NetworkVO defaultNetwork;
List<? extends Network> virtualNetworks = _networkModel.listNetworksForAccount(newAccount.getId(), zone.getId(), Network.GuestType.Isolated);
if (virtualNetworks.isEmpty()) {
defaultNetwork = createApplicableNetworkToCreateVm(caller, newAccount, zone, firstRequiredOffering);
throw new CloudRuntimeException(String.format("Could not find an applicable network to create virtual machine for account [%s].", newAccount));
} else if (virtualNetworks.size() > 1) {
throw new InvalidParameterValueException(String.format("More than one default isolated network has been found for account [%s]; please specify networkIDs.",
newAccount));
@ -8146,13 +8203,15 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
* @throws InsufficientCapacityException
* @throws ResourceAllocationException
*/
protected NetworkVO createApplicableNetworkToCreateVm(Account caller, Account newAccount, DataCenterVO zone, NetworkOfferingVO requiredOffering)
protected NetworkVO createApplicableNetworkToCreateVm(Account newAccount, DataCenterVO zone)
throws InsufficientCapacityException, ResourceAllocationException {
logger.trace("Creating an applicable network to create the VM.");
NetworkVO defaultNetwork;
Long zoneId = zone.getId();
Account caller = CallContext.current().getCallingAccount();
NetworkOfferingVO requiredOffering = getOfferingWithRequiredAvailabilityForNetworkCreation();
String requiredOfferingTags = requiredOffering.getTags();
long physicalNetworkId = _networkModel.findPhysicalNetworkId(zoneId, requiredOfferingTags, requiredOffering.getTrafficType());
@ -8162,14 +8221,13 @@ public class UserVmManagerImpl extends ManagerBase implements UserVmManager, Vir
throw new InvalidParameterValueException(String.format("Unable to find physical network with ID [%s] and tag [%s].", physicalNetworkId, requiredOfferingTags));
}
Long requiredOfferingId = requiredOffering.getId();
long requiredOfferingId = requiredOffering.getId();
logger.debug("Creating network for account [{}] from the network offering [{}] as a part of VM deployment process.", newAccount, requiredOfferingId);
String newAccountName = newAccount.getAccountName();
Network newNetwork = _networkMgr.createGuestNetwork(requiredOfferingId, newAccountName + "-network",
newAccountName + "-network", null, null, null, false, null, newAccount,
null, physicalNetwork, zoneId, ACLType.Account, null, null,
null, null, true, null, null, null, null, null, null, null, null, null, null, null);
String networkName = String.format("%s-network", newAccount.getAccountName());
Network newNetwork = _networkMgr.createGuestNetwork(requiredOfferingId, networkName, networkName, null, null, null,
false, null, newAccount, null, physicalNetwork, zoneId, ACLType.Account, null, null, null, null, true, null,
null, null, null, null, null, null, null, null, null, null);
if (requiredOffering.isPersistent()) {
newNetwork = implementNetwork(caller, zone, newNetwork);

109
server/src/test/java/com/cloud/vm/UserVmManagerImplTest.java
View File

@ -1975,12 +1975,12 @@ public class UserVmManagerImplTest {
public void updateVmNetworkTestCallsUpdateBasicTypeNetworkForVmIfBasicTypeZone() throws InsufficientCapacityException, ResourceAllocationException {
Mockito.doReturn(_dcMock).when(_dcDao).findById(Mockito.anyLong());
Mockito.doReturn(DataCenter.NetworkType.Basic).when(_dcMock).getNetworkType();
Mockito.doNothing().when(userVmManagerImpl).updateBasicTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.doNothing().when(userVmManagerImpl).updateBasicTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any());
userVmManagerImpl.updateVmNetwork(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock);
Mockito.verify(userVmManagerImpl).updateBasicTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.verify(userVmManagerImpl).updateBasicTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any());
}
@ -1988,12 +1988,12 @@ public class UserVmManagerImplTest {
public void updateVmNetworkTestCallsUpdateAdvancedTypeNetworkForVmIfNotBasicTypeZone() throws InsufficientCapacityException, ResourceAllocationException {
Mockito.doReturn(_dcMock).when(_dcDao).findById(Mockito.anyLong());
Mockito.doReturn(DataCenter.NetworkType.Advanced).when(_dcMock).getNetworkType();
Mockito.doNothing().when(userVmManagerImpl).updateAdvancedTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.doNothing().when(userVmManagerImpl).updateAdvancedTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any());
userVmManagerImpl.updateVmNetwork(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock);
Mockito.verify(userVmManagerImpl).updateAdvancedTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.verify(userVmManagerImpl).updateAdvancedTypeNetworkForVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any());
}
@ -2063,40 +2063,37 @@ public class UserVmManagerImplTest {
}
@Test
public void addNetworksToNetworkIdListTestCallsKeepOldSharedNetworkForVmAddAdditionalNetworksToVmAndCleanupOfOldOwnerNicsForNetwork() {
public void addNetworksToNetworkIdListTestCallsKeepOldSharedNetworkForVmAndAddAdditionalNetworksToVm() {
LinkedList<Long> networkIdList = new LinkedList<Long>();
HashSet<NetworkVO> applicableNetworks = new HashSet<NetworkVO>();
HashMap<Long, String> requestedIPv4ForNics = new HashMap<Long, String>();
HashMap<Long, String> requestedIPv6ForNics = new HashMap<Long, String>();
userVmManagerImpl.addNetworksToNetworkIdList(userVmVoMock, accountMock, virtualMachineProfileMock, networkIdList, applicableNetworks, requestedIPv4ForNics,
userVmManagerImpl.addNetworksToNetworkIdList(userVmVoMock, accountMock, networkIdList, applicableNetworks, requestedIPv4ForNics,
requestedIPv6ForNics);
Mockito.verify(userVmManagerImpl).keepOldSharedNetworkForVm(userVmVoMock, accountMock, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
Mockito.verify(userVmManagerImpl).addAdditionalNetworksToVm(userVmVoMock, accountMock, networkIdList, applicableNetworks, requestedIPv4ForNics, requestedIPv6ForNics);
Mockito.verify(userVmManagerImpl).cleanupOfOldOwnerNicsForNetwork(virtualMachineProfileMock);
}
@Test
public void selectApplicableNetworkToCreateVmTestRequiredOfferingsListHasNoOfferingsThrowsInvalidParameterValueException() {
public void getOfferingWithRequiredAvailabilityForNetworkCreationTestRequiredOfferingsListHasNoOfferingsThrowsInvalidParameterValueException() {
String expectedMessage = String.format("Unable to find network offering with availability [%s] to automatically create the network as a part of VM creation.",
NetworkOffering.Availability.Required);
HashSet<NetworkVO> applicableNetworks = new HashSet<NetworkVO>();
LinkedList<NetworkOfferingVO> requiredOfferings = new LinkedList<NetworkOfferingVO>();
LinkedList<NetworkOfferingVO> requiredOfferings = new LinkedList<>();
Mockito.doReturn(requiredOfferings).when(networkOfferingDaoMock).listByAvailability(NetworkOffering.Availability.Required, false);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.selectApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, applicableNetworks);
userVmManagerImpl.getOfferingWithRequiredAvailabilityForNetworkCreation();
});
Assert.assertEquals(expectedMessage, assertThrows.getMessage());
}
@Test
public void selectApplicableNetworkToCreateVmTestFirstOfferingIsNotEnabledThrowsInvalidParameterValueException() {
public void getOfferingWithRequiredAvailabilityForNetworkCreationTestFirstOfferingIsNotEnabledThrowsInvalidParameterValueException() {
String expectedMessage = String.format("Required network offering ID [%s] is not in [%s] state.", 1l, NetworkOffering.State.Enabled);
HashSet<NetworkVO> applicableNetworks = new HashSet<NetworkVO>();
Mockito.doReturn(networkOfferingVoListMock).when(networkOfferingDaoMock).listByAvailability(NetworkOffering.Availability.Required, false);
Mockito.doReturn(networkOfferingVoMock).when(networkOfferingVoListMock).get(0);
@ -2106,30 +2103,22 @@ public class UserVmManagerImplTest {
Mockito.doReturn(1l).when(networkOfferingVoMock).getId();
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.selectApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, applicableNetworks);
userVmManagerImpl.getOfferingWithRequiredAvailabilityForNetworkCreation();
});
Assert.assertEquals(expectedMessage, assertThrows.getMessage());
}
@Test
public void selectApplicableNetworkToCreateVmTestVirtualNetworkIsEmptyCallsCreateApplicableNetworkToCreateVm() throws InsufficientCapacityException,
@Test(expected = CloudRuntimeException.class)
public void selectApplicableNetworkToCreateVmTestVirtualNetworkIsEmptyThrowsException() throws InsufficientCapacityException,
ResourceAllocationException {
HashSet<NetworkVO> applicableNetworks = new HashSet<NetworkVO>();
HashSet<NetworkVO> applicableNetworks = new HashSet<>();
LinkedList<? extends Network> virtualNetworks = new LinkedList<>();
Mockito.doReturn(networkOfferingVoListMock).when(networkOfferingDaoMock).listByAvailability(NetworkOffering.Availability.Required, false);
Mockito.doReturn(networkOfferingVoMock).when(networkOfferingVoListMock).get(0);
Mockito.doReturn(virtualNetworks).when(networkModel).listNetworksForAccount(Mockito.anyLong(), Mockito.anyLong(), Mockito.any());
Mockito.doReturn(NetworkOffering.State.Enabled).when(networkOfferingVoMock).getState();
Mockito.doReturn(networkMock).when(userVmManagerImpl).createApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
userVmManagerImpl.selectApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, applicableNetworks);
Mockito.verify(userVmManagerImpl).createApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, networkOfferingVoMock);
userVmManagerImpl.selectApplicableNetworkToCreateVm(accountMock, _dcMock, applicableNetworks);
}
@Test
@ -2138,17 +2127,13 @@ public class UserVmManagerImplTest {
HashSet<NetworkVO> applicableNetworks = new HashSet<NetworkVO>();
LinkedList<NetworkVO> virtualNetworks = new LinkedList<NetworkVO>();
Mockito.doReturn(networkOfferingVoListMock).when(networkOfferingDaoMock).listByAvailability(NetworkOffering.Availability.Required, false);
Mockito.doReturn(networkOfferingVoMock).when(networkOfferingVoListMock).get(0);
Mockito.doReturn(virtualNetworks).when(networkModel).listNetworksForAccount(Mockito.anyLong(), Mockito.anyLong(), Mockito.any());
Mockito.doReturn(NetworkOffering.State.Enabled).when(networkOfferingVoMock).getState();
virtualNetworks.add(networkMock);
virtualNetworks.add(networkMock);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.selectApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, applicableNetworks);
userVmManagerImpl.selectApplicableNetworkToCreateVm(accountMock, _dcMock, applicableNetworks);
});
Assert.assertEquals(expectedMessage, assertThrows.getMessage());
@ -2158,17 +2143,13 @@ public class UserVmManagerImplTest {
public void selectApplicableNetworkToCreateVmTestVirtualNetworkHasOneNetworkCallsNetworkDaoFindById() throws InsufficientCapacityException, ResourceAllocationException {
HashSet<NetworkVO> applicableNetworks = new HashSet<NetworkVO>();
Mockito.doReturn(networkOfferingVoListMock).when(networkOfferingDaoMock).listByAvailability(NetworkOffering.Availability.Required, false);
Mockito.doReturn(networkOfferingVoMock).when(networkOfferingVoListMock).get(0);
Mockito.doReturn(networkVoListMock).when(networkModel).listNetworksForAccount(Mockito.anyLong(), Mockito.anyLong(), Mockito.any());
Mockito.doReturn(NetworkOffering.State.Enabled).when(networkOfferingVoMock).getState();
Mockito.doReturn(false).when(networkVoListMock).isEmpty();
Mockito.doReturn(1).when(networkVoListMock).size();
Mockito.doReturn(networkMock).when(networkVoListMock).get(0);
userVmManagerImpl.selectApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, applicableNetworks);
userVmManagerImpl.selectApplicableNetworkToCreateVm(accountMock, _dcMock, applicableNetworks);
Mockito.verify(_networkDao).findById(Mockito.anyLong());
}
@ -2457,9 +2438,11 @@ public class UserVmManagerImplTest {
@Test
public void createApplicableNetworkToCreateVmTestPhysicalNetworkIsNullThrowsInvalidParameterValueException() {
Mockito.doReturn(networkOfferingVoMock).when(userVmManagerImpl).getOfferingWithRequiredAvailabilityForNetworkCreation();
String expectedMessage = String.format("Unable to find physical network with ID [%s] and tag [%s].", 0l, null);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.createApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, networkOfferingVoMock);
userVmManagerImpl.createApplicableNetworkToCreateVm(accountMock, _dcMock);
});
Assert.assertEquals(expectedMessage, assertThrows.getMessage());
@ -2471,11 +2454,17 @@ public class UserVmManagerImplTest {
Mockito.doReturn(physicalNetworkVo).when(physicalNetworkDaoMock).findById(Mockito.anyLong());
Mockito.doReturn(true).when(networkOfferingVoMock).isPersistent();
Mockito.doReturn(networkOfferingVoMock).when(userVmManagerImpl).getOfferingWithRequiredAvailabilityForNetworkCreation();
Mockito.doReturn(networkMock).when(userVmManagerImpl).implementNetwork(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(networkMock).when(_networkMgr).createGuestNetwork(Mockito.anyLong(), Mockito.anyString(),
Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyBoolean(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.anyBoolean(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
userVmManagerImpl.createApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, networkOfferingVoMock);
userVmManagerImpl.createApplicableNetworkToCreateVm(accountMock, _dcMock);
Mockito.verify(userVmManagerImpl).implementNetwork(callerAccount, _dcMock, null);
Mockito.verify(userVmManagerImpl).implementNetwork(callerAccount, _dcMock, networkMock);
}
@Test
@ -2485,16 +2474,16 @@ public class UserVmManagerImplTest {
PhysicalNetworkVO physicalNetworkVo = new PhysicalNetworkVO();
Mockito.doReturn(physicalNetworkVo).when(physicalNetworkDaoMock).findById(Mockito.anyLong());
Mockito.doReturn(false).when(networkOfferingVoMock).isPersistent();
Mockito.doReturn(networkMock).when(_networkMgr).createGuestNetwork(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(),
Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyBoolean(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.anyLong(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.anyBoolean(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(networkMock).when(_networkMgr).createGuestNetwork(Mockito.anyLong(), Mockito.anyString(),
Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyBoolean(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.anyBoolean(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(networkOfferingVoMock).when(userVmManagerImpl).getOfferingWithRequiredAvailabilityForNetworkCreation();
Mockito.doReturn(1l).when(networkMock).getId();
Mockito.doReturn(networkMock).when(_networkDao).findById(Mockito.anyLong());
userVmManagerImpl.createApplicableNetworkToCreateVm(callerAccount, accountMock, _dcMock, networkOfferingVoMock);
userVmManagerImpl.createApplicableNetworkToCreateVm(accountMock, _dcMock);
Mockito.verify(userVmManagerImpl, Mockito.never()).implementNetwork(Mockito.any(), Mockito.any(), Mockito.any());
}
@ -2679,7 +2668,7 @@ public class UserVmManagerImplTest {
networkIdList.add(1l);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.updateBasicTypeNetworkForVm(assignVmCmdMock, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock, networkIdList,
userVmManagerImpl.updateBasicTypeNetworkForVm(userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock, networkIdList,
securityGroupIdList);
});
@ -2694,7 +2683,7 @@ public class UserVmManagerImplTest {
Mockito.doReturn(networkMock).when(networkModel).getExclusiveGuestNetwork(Mockito.anyLong());
userVmManagerImpl.updateBasicTypeNetworkForVm(assignVmCmdMock, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock, null,
userVmManagerImpl.updateBasicTypeNetworkForVm(userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock, null,
securityGroupIdList);
Mockito.verify(userVmManagerImpl).cleanupOfOldOwnerNicsForNetwork(virtualMachineProfileMock);
@ -2712,7 +2701,7 @@ public class UserVmManagerImplTest {
Mockito.doReturn(networkMock).when(networkModel).getExclusiveGuestNetwork(Mockito.anyLong());
userVmManagerImpl.updateBasicTypeNetworkForVm(assignVmCmdMock, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock, networkIdList,
userVmManagerImpl.updateBasicTypeNetworkForVm(userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock, networkIdList,
securityGroupIdList);
Mockito.verify(userVmManagerImpl).cleanupOfOldOwnerNicsForNetwork(virtualMachineProfileMock);
@ -2730,7 +2719,7 @@ public class UserVmManagerImplTest {
Mockito.doReturn(true).when(networkModel).checkSecurityGroupSupportForNetwork(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.updateAdvancedTypeNetworkForVm(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock,
userVmManagerImpl.updateAdvancedTypeNetworkForVm(callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock,
_dcMock, networkIdList, securityGroupIdList);
});
@ -2751,7 +2740,7 @@ public class UserVmManagerImplTest {
Mockito.doReturn(true).when(networkModel).checkSecurityGroupSupportForNetwork(accountMock, _dcMock, networkIdList, securityGroupIdList);
userVmManagerImpl.updateAdvancedTypeNetworkForVm(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock,
userVmManagerImpl.updateAdvancedTypeNetworkForVm(callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock,
networkIdList, securityGroupIdList);
Mockito.verify(securityGroupManagerMock).removeInstanceFromGroups(Mockito.any());
@ -2770,7 +2759,7 @@ public class UserVmManagerImplTest {
Mockito.doReturn(false).when(networkModel).checkSecurityGroupSupportForNetwork(accountMock, _dcMock, networkIdList, securityGroupIdList);
InvalidParameterValueException assertThrows = Assert.assertThrows(expectedInvalidParameterValueException, () -> {
userVmManagerImpl.updateAdvancedTypeNetworkForVm(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock,
userVmManagerImpl.updateAdvancedTypeNetworkForVm(callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock,
_dcMock, networkIdList, securityGroupIdList);
});
@ -2785,16 +2774,17 @@ public class UserVmManagerImplTest {
LinkedList<Long> networkIdList = new LinkedList<Long>();
Mockito.doReturn(networkMock).when(userVmManagerImpl).addNicsToApplicableNetworksAndReturnDefaultNetwork(Mockito.any(), Mockito.anyMap(), Mockito.anyMap(), Mockito.any());
Mockito.doNothing().when(userVmManagerImpl).selectApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doNothing().when(userVmManagerImpl).selectApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(false).when(networkModel).checkSecurityGroupSupportForNetwork(accountMock, _dcMock, networkIdList, securityGroupIdList);
Mockito.doReturn(true).when(securityGroupIdList).isEmpty();
userVmManagerImpl.updateAdvancedTypeNetworkForVm(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock,
userVmManagerImpl.updateAdvancedTypeNetworkForVm(callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock,
networkIdList, securityGroupIdList);
Mockito.verify(userVmManagerImpl).addNetworksToNetworkIdList(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyMap(), Mockito.anyMap());
Mockito.verify(userVmManagerImpl).selectApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(userVmManagerImpl).addNetworksToNetworkIdList(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyMap(), Mockito.anyMap());
Mockito.verify(userVmManagerImpl).cleanupOfOldOwnerNicsForNetwork(Mockito.any());
Mockito.verify(userVmManagerImpl).selectApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(userVmManagerImpl).addNicsToApplicableNetworksAndReturnDefaultNetwork(Mockito.any(), Mockito.anyMap(), Mockito.anyMap(), Mockito.any());
Mockito.verify(userVmManagerImpl).allocateNetworksForVm(Mockito.any(), Mockito.any());
}
@ -2813,11 +2803,12 @@ public class UserVmManagerImplTest {
Mockito.doReturn(networkMock).when(_networkDao).findById(Mockito.anyLong());
Mockito.doReturn(true).when(userVmManagerImpl).canAccountUseNetwork(accountMock, networkMock);
userVmManagerImpl.updateAdvancedTypeNetworkForVm(assignVmCmdMock, callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock,
userVmManagerImpl.updateAdvancedTypeNetworkForVm(callerAccount, userVmVoMock, accountMock, virtualMachineTemplateMock, virtualMachineProfileMock, _dcMock,
networkIdList, securityGroupIdList);
Mockito.verify(userVmManagerImpl).addNetworksToNetworkIdList(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyMap(), Mockito.anyMap());
Mockito.verify(userVmManagerImpl, Mockito.never()).selectApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(userVmManagerImpl).addNetworksToNetworkIdList(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyMap(), Mockito.anyMap());
Mockito.verify(userVmManagerImpl).cleanupOfOldOwnerNicsForNetwork(Mockito.any());
Mockito.verify(userVmManagerImpl, Mockito.never()).selectApplicableNetworkToCreateVm(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.verify(userVmManagerImpl).addNicsToApplicableNetworksAndReturnDefaultNetwork(Mockito.any(), Mockito.anyMap(), Mockito.anyMap(), Mockito.any());
Mockito.verify(userVmManagerImpl).allocateNetworksForVm(Mockito.any(), Mockito.any());
}

1
test/integration/smoke/test_global_acls.py
View File

@ -141,6 +141,7 @@ class TestGlobalACLs(cloudstackTestCase):
# Creating ACL list
acl = NetworkACLList.create(apiclient=self.apiclient, services={}, name="acl", description="acl")
self.cleanup.append(acl)
# Creating tier on VPC with ACL list
network = Network.create(

2
utils/src/main/java/com/cloud/utils/net/NetUtils.java
View File

@ -847,7 +847,7 @@ public class NetUtils {
isSuperset, isSubset, neitherSubetNorSuperset, sameSubnet, errorInCidrFormat
}
public static SupersetOrSubset isNetowrkASubsetOrSupersetOfNetworkB(final String cidrA, final String cidrB) {
public static SupersetOrSubset isNetworkASubsetOrSupersetOfNetworkB(final String cidrA, final String cidrB) {
if (!areCidrsNotEmpty(cidrA, cidrB)) {
return SupersetOrSubset.errorInCidrFormat;
}

4
utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
View File

@ -562,8 +562,8 @@ public class NetUtilsTest {
}
@Test
public void testIsNetowrkASubsetOrSupersetOfNetworkBWithEmptyValues() {
assertEquals(SupersetOrSubset.errorInCidrFormat, NetUtils.isNetowrkASubsetOrSupersetOfNetworkB("", null));
public void testIsNetworkASubsetOrSupersetOfNetworkBWithEmptyValues() {
assertEquals(SupersetOrSubset.errorInCidrFormat, NetUtils.isNetworkASubsetOrSupersetOfNetworkB("", null));
}
@Test