etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Cloudstack-3753 Multiple VLAN range API need to accept a list rather than "add" or "remove" per command 

Reviewed-by: Alena Prokharchyk

Conflicts:
	server/test/com/cloud/network/MockNetworkManagerImpl.java
This commit is contained in:
Bharat Kumar 2013-07-25 01:18:21 +05:30 committed by Alena Prokharchyk
parent 3a928d7db0
commit 21f1b137cb
8 changed files with 194 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/src/com/cloud/network/NetworkService.java
View File

@ -87,7 +87,7 @@ public interface NetworkService {
Long startIndex, Long pageSize, String name);
PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List<String> tags,
String newVnetRangeString, String state, String removeVlan);
String newVnetRangeString, String state);
boolean deletePhysicalNetwork(Long id);

8
api/src/org/apache/cloudstack/api/command/admin/network/UpdatePhysicalNetworkCmd.java
View File

@ -54,8 +54,6 @@ public class UpdatePhysicalNetworkCmd extends BaseAsyncCmd {
@Parameter(name=ApiConstants.VLAN, type=CommandType.STRING, description="the VLAN for the physical network")
private String vlan;
@Parameter(name=ApiConstants.REMOVE_VLAN, type = CommandType.STRING, description ="The vlan range we want to remove")
private String removevlan;
/////////////////////////////////////////////////////
/////////////////// Accessors ///////////////////////
@ -81,10 +79,6 @@ public class UpdatePhysicalNetworkCmd extends BaseAsyncCmd {
return vlan;
}
public String getRemoveVlan(){
return removevlan;
}
/////////////////////////////////////////////////////
/////////////// API Implementation///////////////////
/////////////////////////////////////////////////////
@ -101,7 +95,7 @@ public class UpdatePhysicalNetworkCmd extends BaseAsyncCmd {
@Override
public void execute(){
PhysicalNetwork result = _networkService.updatePhysicalNetwork(getId(),getNetworkSpeed(), getTags(), getVlan(), getState(), getRemoveVlan());
PhysicalNetwork result = _networkService.updatePhysicalNetwork(getId(),getNetworkSpeed(), getTags(), getVlan(), getState());
PhysicalNetworkResponse response = _responseGenerator.createPhysicalNetworkResponse(result);
response.setResponseName(getCommandName());
this.setResponseObject(response);

2
engine/schema/src/com/cloud/dc/dao/DataCenterVnetDao.java
View File

@ -33,7 +33,7 @@ public interface DataCenterVnetDao extends GenericDao<DataCenterVnetVO, Long> {
public void delete(long physicalNetworkId);
public void deleteRange(Transaction txn, long dcId, long physicalNetworkId, int start, int end);
public void deleteVnets(Transaction txn, long dcId, long physicalNetworkId, List<String> vnets);
public void lockRange(long dcId, long physicalNetworkId, Integer start, Integer end);

24
engine/schema/src/com/cloud/dc/dao/DataCenterVnetDaoImpl.java
View File

@ -110,9 +110,10 @@ public class DataCenterVnetDaoImpl extends GenericDaoBase<DataCenterVnetVO, Long
sc.setParameters("vnet", vnet);
return listBy(sc);
}
@DB
}
@DB //In the List<string> argument each string is a vlan. not a vlanRange.
public void add(long dcId, long physicalNetworkId, List<String> vnets) {
String insertVnet = "INSERT INTO `cloud`.`op_dc_vnet_alloc` (vnet, data_center_id, physical_network_id) VALUES ( ?, ?, ?)";
@ -133,15 +134,18 @@ public class DataCenterVnetDaoImpl extends GenericDaoBase<DataCenterVnetVO, Long
}
}
public void deleteRange(Transaction txn, long dcId, long physicalNetworkId, int start, int end) {
String deleteVnet = "DELETE FROM `cloud`.`op_dc_vnet_alloc` WHERE data_center_id=? AND physical_network_id=? AND taken IS NULL AND vnet BETWEEN ? AND ?";
//In the List<string> argument each string is a vlan. not a vlanRange.
public void deleteVnets(Transaction txn, long dcId, long physicalNetworkId, List<String> vnets) {
String deleteVnet = "DELETE FROM `cloud`.`op_dc_vnet_alloc` WHERE data_center_id=? AND physical_network_id=? AND taken IS NULL AND vnet=?";
try {
PreparedStatement stmt = txn.prepareAutoCloseStatement(deleteVnet);
stmt.setLong(1,dcId);
stmt.setLong(2,physicalNetworkId);
stmt.setString(3,((Integer)start).toString());
stmt.setString(4,((Integer)end).toString());
stmt.execute();
for (int i =0; i <= vnets.size()-1; i++) {
stmt.setLong(1,dcId);
stmt.setLong(2,physicalNetworkId);
stmt.setString(3, vnets.get(i));
stmt.addBatch();
}
stmt.executeBatch();
} catch (SQLException e) {
throw new CloudRuntimeException("Exception caught adding vnet ", e);
}

2
engine/schema/src/com/cloud/network/dao/PhysicalNetworkVO.java
View File

@ -206,7 +206,7 @@ public class PhysicalNetworkVO implements PhysicalNetwork {
public List<Pair<Integer, Integer>> getVnet() {
List <Pair<Integer,Integer>> vnetList = new ArrayList<Pair<Integer, Integer>>();
if (vnet != null) {
String [] Temp = vnet.split(";");
String [] Temp = vnet.split(",");
String [] vnetSplit = null;
for (String vnetRange : Temp){
vnetSplit = vnetRange.split("-");

350
server/src/com/cloud/network/NetworkServiceImpl.java
View File

@ -2410,34 +2410,12 @@ public class NetworkServiceImpl extends ManagerBase implements NetworkService {
throw new InvalidParameterException("Only one isolationMethod can be specified for a physical network at this time");
}
int vnetStart = 0;
int vnetEnd = 0;
long minVnet = MIN_VLAN_ID;
long maxVnet = MAX_VLAN_ID;
// Wondering why GRE doesn't check its vNet range here. While they check it in processVlanRange called by updatePhysicalNetwork.
if (vnetRange != null) {
// Verify zone type
if (zoneType == NetworkType.Basic
|| (zoneType == NetworkType.Advanced && zone.isSecurityGroupEnabled())) {
throw new InvalidParameterValueException("Can't add vnet range to the physical network in the zone that supports " + zoneType + " network, Security Group enabled: " + zone.isSecurityGroupEnabled());
}
String[] tokens = vnetRange.split("-");
try {
vnetStart = Integer.parseInt(tokens[0]);
if (tokens.length == 1) {
vnetEnd = vnetStart;
} else {
vnetEnd = Integer.parseInt(tokens[1]);
}
} catch (NumberFormatException e) {
throw new InvalidParameterValueException("Please specify valid integers for the vlan range.");
}
if ((vnetStart > vnetEnd) || (vnetStart < minVnet) || (vnetEnd > maxVnet)) {
s_logger.warn("Invalid vnet range: start range:" + vnetStart + " end range:" + vnetEnd);
throw new InvalidParameterValueException("Vnet range should be between " + minVnet + "-" + maxVnet + " and start range should be lesser than or equal to end range");
}
}
BroadcastDomainRange broadcastDomainRange = null;
@ -2476,14 +2454,8 @@ public class NetworkServiceImpl extends ManagerBase implements NetworkService {
pNetwork = _physicalNetworkDao.persist(pNetwork);
// Add vnet entries for the new zone if zone type is Advanced
List <String> vnets = new ArrayList<String>();
for (Integer i= vnetStart; i<= vnetEnd; i++ ) {
vnets.add(i.toString());
}
if (vnetRange != null) {
_dcDao.addVnet(zone.getId(), pNetwork.getId(), vnets);
addOrRemoveVnets(vnetRange.split(","), pNetwork);
}
// add VirtualRouter as the default network service provider
@ -2533,7 +2505,7 @@ public class NetworkServiceImpl extends ManagerBase implements NetworkService {
@Override
@DB
@ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_UPDATE, eventDescription = "updating physical network", async = true)
public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List<String> tags, String newVnetRange, String state, String removeVlan) {
public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List<String> tags, String newVnetRange, String state) {
// verify input parameters
PhysicalNetworkVO network = _physicalNetworkDao.findById(id);
@ -2558,11 +2530,6 @@ public class NetworkServiceImpl extends ManagerBase implements NetworkService {
}
}
if (removeVlan != null){
List<Integer> tokens = processVlanRange(network,removeVlan);
removeVlanRange(network, tokens.get(0), tokens.get(1));
}
if (tags != null && tags.size() > 1) {
throw new InvalidParameterException("Unable to support more than one tag on network yet");
}
@ -2588,173 +2555,204 @@ public class NetworkServiceImpl extends ManagerBase implements NetworkService {
network.setSpeed(networkSpeed);
}
// Vnet range can be extended only
boolean AddVnet = true;
List<Pair<Integer, Integer>> vnetsToAdd = new ArrayList<Pair<Integer, Integer>>();
List<Integer> tokens = null;
List<String> add_Vnet = null;
if (newVnetRange != null) {
tokens = processVlanRange(network, newVnetRange);
HashSet<String> vnetsInDb = new HashSet<String>();
vnetsInDb.addAll(_datacneter_vnet.listVnetsByPhysicalNetworkAndDataCenter(network.getDataCenterId(), id));
HashSet<String> tempVnets = new HashSet<String>();
tempVnets.addAll(vnetsInDb);
for (Integer i = tokens.get(0); i <= tokens.get(1); i++) {
tempVnets.add(i.toString());
}
tempVnets.removeAll(vnetsInDb);
if (tempVnets.isEmpty()) {
throw new InvalidParameterValueException("The vlan range you are trying to add already exists.");
}
vnetsInDb.addAll(tempVnets);
add_Vnet = new ArrayList<String>();
add_Vnet.addAll(tempVnets);
List<String> sortedList = new ArrayList<String>(vnetsInDb);
Collections.sort(sortedList, new Comparator<String>() {
public int compare(String s1, String s2) {
return Integer.valueOf(s1).compareTo(Integer.valueOf(s2));
}
});
//build the vlan string form the allocated vlan list.
String vnetRange = "";
String startvnet = sortedList.get(0);
String endvnet = "";
for ( int i =0; i < sortedList.size()-1; i++ ) {
if (Integer.valueOf(sortedList.get(i+1)) - Integer.valueOf(sortedList.get(i)) > 1) {
endvnet = sortedList.get(i);
vnetRange=vnetRange + startvnet+"-"+endvnet+";";
startvnet = sortedList.get(i+1);
}
}
endvnet = sortedList.get(sortedList.size()-1);
vnetRange=vnetRange + startvnet+"-"+endvnet+";";
vnetRange = vnetRange.substring(0,vnetRange.length()-1);
network.setVnet(vnetRange);
}
Transaction txn = Transaction.currentTxn();
txn.start();
if (add_Vnet != null) {
s_logger.debug("Adding vnet range " + tokens.get(0).toString() + "-" + tokens.get(1).toString() + " for the physicalNetwork id= " + id + " and zone id=" + network.getDataCenterId()
+ " as a part of updatePhysicalNetwork call");
_dcDao.addVnet(network.getDataCenterId(), network.getId(), add_Vnet);
String [] listOfRanges = newVnetRange.split(",");
addOrRemoveVnets(listOfRanges, network);
}
_physicalNetworkDao.update(id, network);
txn.commit();
return network;
}
private List<Integer> processVlanRange(PhysicalNetworkVO network, String vlan) {
@DB
public void addOrRemoveVnets(String [] listOfRanges, PhysicalNetworkVO network) {
List<String> addVnets = null;
List<String> removeVnets =null;
HashSet<String> tempVnets = new HashSet<String>();
HashSet<String> vnetsInDb = new HashSet<String>();
List<Pair<Integer, Integer>> vnetranges = null;
String comaSeperatedStingOfVnetRanges = null;
int i =0;
if (listOfRanges.length !=0) {
_physicalNetworkDao.acquireInLockTable(network.getId(),10);
vnetranges = validateVlanRange(network, listOfRanges);
//computing vnets to be removed.
removeVnets = getVnetsToremove(network, vnetranges);
//computing vnets to add
vnetsInDb.addAll(_datacneter_vnet.listVnetsByPhysicalNetworkAndDataCenter(network.getDataCenterId(), network.getId()));
tempVnets.addAll(vnetsInDb);
for (Pair<Integer, Integer>vlan : vnetranges) {
for (i= vlan.first(); i<= vlan.second(); i++) {
tempVnets.add(Integer.toString(i));
}
}
tempVnets.removeAll(vnetsInDb);
//vnets to add in tempVnets.
//adding and removing vnets from vnetsInDb
if (removeVnets != null && removeVnets.size() !=0 ) {
vnetsInDb.removeAll(removeVnets);
}
if (tempVnets.size() != 0) {
addVnets = new ArrayList<String>();
addVnets.addAll(tempVnets);
vnetsInDb.addAll(tempVnets);
}
//sorting the vnets in Db to generate a coma seperated list of the vnet string.
if (vnetsInDb.size() !=0 ) {
comaSeperatedStingOfVnetRanges = generateVnetString( new ArrayList<String>(vnetsInDb));
}
network.setVnet(comaSeperatedStingOfVnetRanges);
Transaction txn = Transaction.currentTxn();
txn.start();
if (addVnets != null) {
s_logger.debug("Adding vnet range " + addVnets.toString()+ " for the physicalNetwork id= " + network.getId() + " and zone id=" + network.getDataCenterId()
+ " as a part of updatePhysicalNetwork call");
//add vnet takes a list of strings to be added. each string is a vnet.
_dcDao.addVnet(network.getDataCenterId(), network.getId(), addVnets);
}
if (removeVnets != null) {
s_logger.debug("removing vnet range " + removeVnets.toString()+ " for the physicalNetwork id= " + network.getId() + " and zone id=" + network.getDataCenterId()
+ " as a part of updatePhysicalNetwork call");
//deleteVnets takes a list of strings to be removed. each string is a vnet.
_datacneter_vnet.deleteVnets(txn, network.getDataCenterId(), network.getId(), removeVnets);
}
_physicalNetworkDao.update(network.getId(), network);
txn.commit();
_physicalNetworkDao.releaseFromLockTable(network.getId());
}
}
private List<Pair<Integer, Integer>> validateVlanRange(PhysicalNetworkVO network, String[] listOfRanges) {
Integer StartVnet;
Integer EndVnet;
String[] VnetRange = vlan.split("-");
List<Pair<Integer,Integer>> vlanTokens = new ArrayList<Pair<Integer, Integer>>();
for (String vlanRange : listOfRanges) {
String[] VnetRange = vlanRange.split("-");
// Init with [min,max] of VLAN. Actually 0x000 and 0xFFF are reserved by IEEE, shoudn't be used.
long minVnet = MIN_VLAN_ID;
long maxVnet = MAX_VLAN_ID;
// Init with [min,max] of VLAN. Actually 0x000 and 0xFFF are reserved by IEEE, shoudn't be used.
long minVnet = MIN_VLAN_ID;
long maxVnet = MAX_VLAN_ID;
// for GRE phynets allow up to 32bits
// TODO: Not happy about this test.
// What about guru-like objects for physical networs?
s_logger.debug("ISOLATION METHODS:" + network.getIsolationMethods());
// Java does not have unsigned types...
if (network.getIsolationMethods().contains("GRE")) {
minVnet = MIN_GRE_KEY;
maxVnet = MAX_GRE_KEY;
}
String rangeMessage = " between " + minVnet + " and " + maxVnet;
if (VnetRange.length < 2) {
throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage);
}
// for GRE phynets allow up to 32bits
// TODO: Not happy about this test.
// What about guru-like objects for physical networs?
s_logger.debug("ISOLATION METHODS:" + network.getIsolationMethods());
// Java does not have unsigned types...
if (network.getIsolationMethods().contains("GRE")) {
minVnet = MIN_GRE_KEY;
maxVnet = MAX_GRE_KEY;
}
String rangeMessage = " between " + minVnet + " and " + maxVnet;
if (VnetRange.length == 1 && VnetRange[0].equals("")) {
return vlanTokens;
}
if (VnetRange.length < 2) {
throw new InvalidParameterValueException("Please provide valid vnet range. vnet range should be a coma seperated list of vlan ranges. example 500-500,600-601" + rangeMessage);
}
if (VnetRange[0] == null || VnetRange[1] == null) {
throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage);
}
if (VnetRange[0] == null || VnetRange[1] == null) {
throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage);
}
try {
StartVnet = Integer.parseInt(VnetRange[0]);
EndVnet = Integer.parseInt(VnetRange[1]);
} catch (NumberFormatException e) {
s_logger.warn("Unable to parse vnet range:", e);
throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage);
}
if (StartVnet < minVnet || EndVnet > maxVnet) {
throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage);
}
try {
StartVnet = Integer.parseInt(VnetRange[0]);
EndVnet = Integer.parseInt(VnetRange[1]);
} catch (NumberFormatException e) {
s_logger.warn("Unable to parse vnet range:", e);
throw new InvalidParameterValueException("Please provide valid vnet range. The vnet range should be a coma seperated list example 2001-2012,3000-3005." + rangeMessage);
}
if (StartVnet < minVnet || EndVnet > maxVnet) {
throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage);
}
if (StartVnet > EndVnet) {
throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage + " and start range should be lesser than or equal to stop range");
if (StartVnet > EndVnet) {
throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage + " and start range should be lesser than or equal to stop range");
}
vlanTokens.add(new Pair<Integer, Integer>(StartVnet, EndVnet));
}
List<Integer> tokens = new ArrayList<Integer>();
tokens.add(StartVnet);
tokens.add(EndVnet);
return tokens;
return vlanTokens;
}
private boolean removeVlanRange( PhysicalNetworkVO network, Integer start, Integer end) {
Integer temp=0;
public String generateVnetString(List<String> vnetList) {
Collections.sort(vnetList, new Comparator<String>() {
public int compare(String s1, String s2) {
return Integer.valueOf(s1).compareTo(Integer.valueOf(s2));
}
});
int i;
List <Pair <Integer,Integer>> existingRanges = network.getVnet();
Transaction txn = Transaction.currentTxn();
txn.start();
_physicalNetworkDao.acquireInLockTable(network.getId(),10);
_datacneter_vnet.lockRange(network.getDataCenterId(), network.getId(), start, end);
List<DataCenterVnetVO> result = _datacneter_vnet.listAllocatedVnetsInRange(network.getDataCenterId(), network.getId(), start, end);
if (!result.isEmpty()){
txn.close();
throw new InvalidParameterValueException("Some of the vnets from this range are allocated, can only remove a range which has no allocated vnets");
}
// If the range is partially dedicated to an account fail the request
List<AccountGuestVlanMapVO> maps = _accountGuestVlanMapDao.listAccountGuestVlanMapsByPhysicalNetwork(network.getId());
for (AccountGuestVlanMapVO map : maps) {
String[] vlans = map.getGuestVlanRange().split("-");
Integer dedicatedStartVlan = Integer.parseInt(vlans[0]);
Integer dedicatedEndVlan = Integer.parseInt(vlans[1]);
if ((start >= dedicatedStartVlan && start <= dedicatedEndVlan) || (end >= dedicatedStartVlan && end <= dedicatedEndVlan)) {
txn.close();
throw new InvalidParameterValueException("Vnet range " + map.getGuestVlanRange() + " is dedicated" +
" to an account. The specified range " + start + "-" + end + " overlaps with the dedicated range " +
" Please release the overlapping dedicated range before deleting the range");
//build the vlan string form the sorted list.
String vnetRange = "";
String startvnet = vnetList.get(0);
String endvnet = "";
for ( i =0; i < vnetList.size()-1; i++ ) {
if (Integer.valueOf(vnetList.get(i+1)) - Integer.valueOf(vnetList.get(i)) > 1) {
endvnet = vnetList.get(i);
vnetRange=vnetRange + startvnet+"-"+endvnet+",";
startvnet = vnetList.get(i+1);
}
}
for (i=0; i<existingRanges.size(); i++){
if (existingRanges.get(i).first()<= start & existingRanges.get(i).second()>= end){
temp = existingRanges.get(i).second();
existingRanges.get(i).second(start - 1);
existingRanges.add(new Pair<Integer, Integer>((end+1),temp));
break;
endvnet = vnetList.get(vnetList.size()-1);
vnetRange=vnetRange + startvnet+"-"+endvnet+",";
vnetRange=vnetRange.substring(0,vnetRange.length()-1);
return vnetRange;
}
private List<String> getVnetsToremove(PhysicalNetworkVO network, List<Pair<Integer, Integer>> vnetRanges) {
int i;
List<String> removeVnets = new ArrayList<String>();
HashSet<String> vnetsInDb = new HashSet<String>();
vnetsInDb.addAll(_datacneter_vnet.listVnetsByPhysicalNetworkAndDataCenter(network.getDataCenterId(), network.getId()));
//remove all the vnets from vnets in db to check if there are any vnets that are not there in given list.
//remove all the vnets not in the list of vnets passed by the user.
if (vnetRanges.size() == 0) {
//this implies remove all vlans.
removeVnets.addAll(vnetsInDb);
return removeVnets;
}
for (Pair<Integer, Integer>vlan : vnetRanges) {
for (i= vlan.first(); i<= vlan.second(); i++) {
vnetsInDb.remove(Integer.toString(i));
}
}
String vnetRange = null;
if (vnetsInDb.size() != 0) {
removeVnets.addAll(vnetsInDb);
vnetRange = generateVnetString(removeVnets);
}else {
return removeVnets;
}
if (temp == 0){
throw new InvalidParameterValueException("The vnet range you are trying to delete does not exist.");
}
if(existingRanges.get(i).first() > existingRanges.get(i).second()){
existingRanges.remove(i);
}
if(existingRanges.get(existingRanges.size()-1).first() > existingRanges.get(existingRanges.size()-1).second()){
existingRanges.remove(existingRanges.size()-1);
}
_datacneter_vnet.deleteRange(txn, network.getDataCenterId(), network.getId(), start, end);
String vnetString="";
if (existingRanges.isEmpty()) {
network.setVnet(null);
} else {
for (Pair<Integer,Integer> vnetRange : existingRanges ) {
vnetString=vnetString+vnetRange.first().toString()+"-"+vnetRange.second().toString()+";";
for (String vnet : vnetRange.split(",")) {
String [] range = vnet.split("-");
Integer start = Integer.parseInt(range[0]);
Integer end= Integer.parseInt(range[1]);
_datacneter_vnet.lockRange(network.getDataCenterId(), network.getId(), start, end);
List<DataCenterVnetVO> result = _datacneter_vnet.listAllocatedVnetsInRange(network.getDataCenterId(), network.getId(), start, end);
if (!result.isEmpty()){
throw new InvalidParameterValueException("Some of the vnets from this range are allocated, can only remove a range which has no allocated vnets");
}
// If the range is partially dedicated to an account fail the request
List<AccountGuestVlanMapVO> maps = _accountGuestVlanMapDao.listAccountGuestVlanMapsByPhysicalNetwork(network.getId());
for (AccountGuestVlanMapVO map : maps) {
String[] vlans = map.getGuestVlanRange().split("-");
Integer dedicatedStartVlan = Integer.parseInt(vlans[0]);
Integer dedicatedEndVlan = Integer.parseInt(vlans[1]);
if ((start >= dedicatedStartVlan && start <= dedicatedEndVlan) || (end >= dedicatedStartVlan && end <= dedicatedEndVlan)) {
throw new InvalidParameterValueException("Vnet range " + map.getGuestVlanRange() + " is dedicated" +
" to an account. The specified range " + start + "-" + end + " overlaps with the dedicated range " +
" Please release the overlapping dedicated range before deleting the range");
}
}
vnetString = vnetString.substring(0, vnetString.length()-1);
network.setVnet(vnetString);
}
_physicalNetworkDao.update(network.getId(), network);
txn.commit();
_physicalNetworkDao.releaseFromLockTable(network.getId());
return true;
return removeVnets;
}

2
server/test/com/cloud/network/UpdatePhysicalNetworkTest.java
View File

@ -65,7 +65,7 @@ public class UpdatePhysicalNetworkTest {
when(_datacenterDao.findById(anyLong())).thenReturn(datacentervo);
when(_physicalNetworkDao.update(anyLong(), any(physicalNetworkVO.getClass()))).thenReturn(true);
when(_DatacenterVnetDao.listVnetsByPhysicalNetworkAndDataCenter(anyLong(), anyLong())).thenReturn(existingRange);
networkService.updatePhysicalNetwork(1l, null, null, "525-530", null, null);
networkService.updatePhysicalNetwork(1l, null, null, "524-524,525-530", null);
txn.close("updatePhysicalNetworkTest");
verify(physicalNetworkVO).setVnet(argumentCaptor.capture());
assertEquals("524-530", argumentCaptor.getValue());

2
server/test/com/cloud/vpc/MockNetworkManagerImpl.java
View File

@ -372,7 +372,7 @@ public class MockNetworkManagerImpl extends ManagerBase implements NetworkManage
*/
@Override
public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List<String> tags,
String newVnetRangeString, String state, String removeVlan) {
String newVnetRangeString, String state) {
// TODO Auto-generated method stub
return null;
}