From b29e3c5a2452fff583d22482673cd954f058b0a3 Mon Sep 17 00:00:00 2001 From: kioie Date: Sun, 29 Mar 2020 09:11:29 +0300 Subject: [PATCH 1/9] Added Logic to update the user_ip_address table --- .../configuration/ConfigurationService.java | 17 ++ .../main/java/com/cloud/event/EventTypes.java | 1 + .../admin/vlan/UpdateVlanIpRangeCmd.java | 158 ++++++++++++++ .../configuration/ConfigurationManager.java | 5 + .../src/main/java/com/cloud/dc/VlanVO.java | 2 +- .../ConfigurationManagerImpl.java | 201 ++++++++++++++++++ .../cloud/server/ManagementServerImpl.java | 2 + .../java/com/cloud/test/IPRangeConfig.java | 44 ++-- .../vpc/MockConfigurationManagerImpl.java | 12 ++ 9 files changed, 421 insertions(+), 21 deletions(-) create mode 100644 api/src/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java diff --git a/api/src/main/java/com/cloud/configuration/ConfigurationService.java b/api/src/main/java/com/cloud/configuration/ConfigurationService.java index 8b419027f702..98fea0ecab77 100644 --- a/api/src/main/java/com/cloud/configuration/ConfigurationService.java +++ b/api/src/main/java/com/cloud/configuration/ConfigurationService.java @@ -39,6 +39,7 @@ import org.apache.cloudstack.api.command.admin.vlan.DedicatePublicIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.DeleteVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd; +import org.apache.cloudstack.api.command.admin.vlan.UpdateVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.zone.CreateZoneCmd; import org.apache.cloudstack.api.command.admin.zone.DeleteZoneCmd; import org.apache.cloudstack.api.command.admin.zone.UpdateZoneCmd; @@ -272,6 +273,22 @@ public interface ConfigurationService { Vlan createVlanAndPublicIpRange(CreateVlanIpRangeCmd cmd) throws InsufficientCapacityException, ConcurrentOperationException, ResourceUnavailableException, ResourceAllocationException; + /** + * Updates the IP address Range for the VLAN on the database, a + * + * @param cmd + * @param vlanId + * @param gateway + * @param startIP + * @param endIP + * @param netmask + * @throws com.cloud.exception.ConcurrentOperationException + * @throws com.cloud.exception.ResourceUnavailableException + * @throws com.cloud.exception.ResourceAllocationException + * @return The updated Vlan object + */ + Vlan updateVlanAndPublicIpRange(UpdateVlanIpRangeCmd cmd) throws ConcurrentOperationException, + ResourceUnavailableException, ResourceAllocationException; /** * Marks the the account with the default zone-id. * diff --git a/api/src/main/java/com/cloud/event/EventTypes.java b/api/src/main/java/com/cloud/event/EventTypes.java index 30b6ac0b0a17..ed60d040645f 100644 --- a/api/src/main/java/com/cloud/event/EventTypes.java +++ b/api/src/main/java/com/cloud/event/EventTypes.java @@ -311,6 +311,7 @@ public class EventTypes { public static final String EVENT_VLAN_IP_RANGE_DELETE = "VLAN.IP.RANGE.DELETE"; public static final String EVENT_VLAN_IP_RANGE_DEDICATE = "VLAN.IP.RANGE.DEDICATE"; public static final String EVENT_VLAN_IP_RANGE_RELEASE = "VLAN.IP.RANGE.RELEASE"; + public static final String EVENT_VLAN_IP_RANGE_UPDATE = "VLAN.IP.RANGE.UPDATE"; public static final String EVENT_MANAGEMENT_IP_RANGE_CREATE = "MANAGEMENT.IP.RANGE.CREATE"; public static final String EVENT_MANAGEMENT_IP_RANGE_DELETE = "MANAGEMENT.IP.RANGE.DELETE"; diff --git a/api/src/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java b/api/src/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java new file mode 100644 index 000000000000..b5e6aff42cd4 --- /dev/null +++ b/api/src/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java @@ -0,0 +1,158 @@ +// 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 org.apache.cloudstack.api.command.admin.vlan; + +import org.apache.cloudstack.api.APICommand; +import org.apache.cloudstack.api.ApiConstants; +import org.apache.cloudstack.api.ApiErrorCode; +import org.apache.cloudstack.api.BaseAsyncCmd; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.Parameter; +import org.apache.cloudstack.api.ServerApiException; +import org.apache.cloudstack.api.response.VlanIpRangeResponse; +import org.apache.log4j.Logger; + +import com.cloud.dc.Vlan; +import com.cloud.event.EventTypes; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.user.Account; +import com.cloud.utils.net.NetUtils; + +@APICommand(name = UpdateVlanIpRangeCmd.APINAME, description = "Updates a VLAN IP range.", responseObject = + VlanIpRangeResponse.class, since = "4.13.0", + requestHasSensitiveInfo = false, responseHasSensitiveInfo = false) +public class UpdateVlanIpRangeCmd extends BaseAsyncCmd { + + public static final String APINAME = "updateVlanIpRange"; + public static final Logger s_logger = Logger.getLogger(UpdateVlanIpRangeCmd.class.getName()); + + ///////////////////////////////////////////////////// + //////////////// API parameters ///////////////////// + ///////////////////////////////////////////////////// + + + @Parameter(name = ApiConstants.ID, type = CommandType.UUID, entityType = VlanIpRangeResponse.class, required = true, + description = "the UUID of the VLAN IP range") + private Long id; + + @Parameter(name = ApiConstants.END_IP, type = CommandType.STRING, + description = "the ending IP address in the VLAN IP range") + private String endIp; + + @Parameter(name = ApiConstants.GATEWAY, type = CommandType.STRING, description = "the gateway of the VLAN IP range") + private String gateway; + + @Parameter(name = ApiConstants.NETMASK, type = CommandType.STRING, description = "the netmask of the VLAN IP range") + private String netmask; + + @Parameter(name = ApiConstants.START_IP, type = CommandType.STRING, description = "the beginning IP address in the VLAN IP range") + private String startIp; + + @Parameter(name = ApiConstants.START_IPV6, type = CommandType.STRING, description = "the beginning IPv6 address in the IPv6 network range") + private String startIpv6; + + @Parameter(name = ApiConstants.END_IPV6, type = CommandType.STRING, description = "the ending IPv6 address in the IPv6 network range") + private String endIpv6; + + @Parameter(name = ApiConstants.VLAN, type = CommandType.INTEGER, description = "Optional. the vlan the ip range sits on") + private Integer vlan; + + ///////////////////////////////////////////////////// + /////////////////// Accessors /////////////////////// + ///////////////////////////////////////////////////// + public Long getId() { + return id; + } + + public String getGateway() { + return gateway; + } + + public String getEndIp() { + return endIp; + } + + public String getNetmask() { + return netmask; + } + + public String getStartIp() { + return startIp; + } + + public String getStartIpv6() { + if (startIpv6 == null) { + return null; + } + return NetUtils.standardizeIp6Address(startIpv6); + } + + public String getEndIpv6() { + if (endIpv6 == null) { + return null; + } + return NetUtils.standardizeIp6Address(endIpv6); + } + + public Integer getVlan() { + return vlan; + } + + ///////////////////////////////////////////////////// + /////////////// API Implementation/////////////////// + ///////////////////////////////////////////////////// + + @Override + public String getEventType() { + return EventTypes.EVENT_VLAN_IP_RANGE_UPDATE; + } + + @Override + public String getEventDescription() { + return "Update vlan ip range " + getId() + " [StartIp=" + getStartIp() + ", EndIp=" + getEndIp() + ", vlan=" + getVlan() + ", netmask=" + getNetmask() + ']'; + } + + + @Override + public void execute() throws ResourceUnavailableException, ResourceAllocationException { + try { + Vlan result = _configService.updateVlanAndPublicIpRange(this); + if (result != null) { + VlanIpRangeResponse response = _responseGenerator.createVlanIpRangeResponse(result); + response.setResponseName(getCommandName()); + this.setResponseObject(response); + } else { + throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to Update vlan ip range"); + } + } catch (ConcurrentOperationException ex) { + s_logger.warn("Exception: ", ex); + throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, ex.getMessage()); + } + } + + @Override + public String getCommandName() { + return APINAME.toLowerCase() + BaseCmd.RESPONSE_SUFFIX; + } + + @Override + public long getEntityOwnerId() { + return Account.ACCOUNT_ID_SYSTEM; + } +} \ No newline at end of file diff --git a/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java b/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java index 162a61e47373..3fc5ab42c122 100644 --- a/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java +++ b/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java @@ -220,6 +220,11 @@ Vlan createVlanAndPublicIpRange(long zoneId, long networkId, long physicalNetwor String vlanGateway, String vlanNetmask, String vlanId, boolean bypassVlanOverlapCheck, Domain domain, Account vlanOwner, String startIPv6, String endIPv6, String vlanIp6Gateway, String vlanIp6Cidr) throws InsufficientCapacityException, ConcurrentOperationException, InvalidParameterValueException; + /* (non-Javadoc) + * @see com.cloud.configuration.ConfigurationManager#updateVlanAndPublicIpRange(long,String,String,String,String) + */ + Vlan updateVlanAndPublicIpRange(long id, String startIp, String endIp, String gateway, String netmask) throws ConcurrentOperationException; + void createDefaultSystemNetworks(long zoneId) throws ConcurrentOperationException; /** diff --git a/engine/schema/src/main/java/com/cloud/dc/VlanVO.java b/engine/schema/src/main/java/com/cloud/dc/VlanVO.java index ebbd4bde08b2..91d2bdb6129e 100644 --- a/engine/schema/src/main/java/com/cloud/dc/VlanVO.java +++ b/engine/schema/src/main/java/com/cloud/dc/VlanVO.java @@ -234,6 +234,6 @@ public void setIp6Range(String ip6Range) { } public void setIpRange(String ipRange) { - this.ip6Range = ipRange; + this.ipRange = ipRange; } } diff --git a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java index 7e9c9d39c2b1..a2c9c8e79ab3 100755 --- a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java +++ b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java @@ -26,6 +26,10 @@ import java.util.Arrays; import java.util.Collection; import java.util.Collections; +<<<<<<< HEAD:server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java +======= +import java.util.Comparator; +>>>>>>> Added Logic to update the user_ip_address table:server/src/com/cloud/configuration/ConfigurationManagerImpl.java import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; @@ -35,10 +39,17 @@ import java.util.Map.Entry; import java.util.Set; import java.util.UUID; +import java.util.Vector; import javax.inject.Inject; import javax.naming.ConfigurationException; +<<<<<<< HEAD:server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java +======= +import com.cloud.network.IpAddress; +import com.google.common.collect.Sets; + +>>>>>>> Added Logic to update the user_ip_address table:server/src/com/cloud/configuration/ConfigurationManagerImpl.java import org.apache.cloudstack.acl.SecurityChecker; import org.apache.cloudstack.affinity.AffinityGroup; import org.apache.cloudstack.affinity.AffinityGroupService; @@ -67,6 +78,7 @@ import org.apache.cloudstack.api.command.admin.vlan.DedicatePublicIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.DeleteVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd; +import org.apache.cloudstack.api.command.admin.vlan.UpdateVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.zone.CreateZoneCmd; import org.apache.cloudstack.api.command.admin.zone.DeleteZoneCmd; import org.apache.cloudstack.api.command.admin.zone.UpdateZoneCmd; @@ -1771,6 +1783,7 @@ private void checkZoneParameters(final String zoneName, final String dns1, final } } + private void checkIpRange(final String startIp, final String endIp, final String cidrAddress, final long cidrSize) { //Checking not null for start IP as well. Previously we assumed to be not null always. //But the check is required for the change in updatePod API. @@ -4075,6 +4088,149 @@ public VlanVO doInTransaction(final TransactionStatus status) { } + @Override + public Vlan updateVlanAndPublicIpRange(UpdateVlanIpRangeCmd cmd) throws ConcurrentOperationException, + ResourceUnavailableException,ResourceAllocationException{ + + return updateVlanAndPublicIpRange(cmd.getId(), cmd.getStartIp(),cmd.getEndIp(), + cmd.getGateway(),cmd.getNetmask()); + } + + @DB + @ActionEvent(eventType = EventTypes.EVENT_VLAN_IP_RANGE_UPDATE, eventDescription = "update vlan ip Range", async + = false) + public Vlan updateVlanAndPublicIpRange(final long id, String startIp, + String endIp, + String gateway, + String netmask) throws ConcurrentOperationException{ + + VlanVO vlanRange = _vlanDao.findById(id); + if (vlanRange == null) { + throw new InvalidParameterValueException("Please specify a valid IP range id."); + } + + if (gateway == null) { + gateway = vlanRange.getVlanGateway(); + } + + if (netmask == null) { + netmask = vlanRange.getVlanNetmask(); + } + + final String[] existingVlanIPRangeArray = vlanRange.getIpRange().split("-"); + final String currentStartIP= existingVlanIPRangeArray[0]; + final String currentEndIP = existingVlanIPRangeArray [1]; + + if(startIp == null){ + startIp= currentStartIP; + } + + if(endIp == null){ + endIp= currentEndIP; + } + + final List ips = _publicIpAddressDao.listByVlanId(id); + checkAllocatedIpsAreWithinVlanRange(ips,startIp,endIp); + + final String cidr = NetUtils.ipAndNetMaskToCidr(gateway, netmask); + final String cidrAddress = getCidrAddress(cidr); + final long cidrSize = getCidrSize(cidr); + + checkIpRange(currentStartIP,currentEndIP,cidrAddress,cidrSize); + + checkIpRange(startIp, endIp, cidrAddress, cidrSize); + + checkGatewayOverlap(startIp,endIp,gateway); + + VlanVO range; + try { + final String newStartIP= startIp; + final String newEndIP= endIp; + + range = _vlanDao.acquireInLockTable(id, 30); + if (range == null) { + throw new CloudRuntimeException("Unable to acquire vlan configuration: " + id); + } + + if (s_logger.isDebugEnabled()) { + s_logger.debug("lock vlan " + id + " is acquired"); + } + + commitUpdateVlanAndIpRange(id, newStartIP, newEndIP, currentStartIP, currentEndIP,true); + + } catch (final Exception e) { + s_logger.error("Unable to edit VlanRange due to " + e.getMessage(), e); + throw new CloudRuntimeException("Failed to edit VlanRange. Please contact Cloud Support."); + }finally { + _vlanDao.releaseFromLockTable(id); + } + + return vlanRange; + } + private VlanVO commitUpdateVlanAndIpRange(final Long id, final String newStartIP, final String newEndIP,final String currentStartIP, final String currentEndIP, final boolean ipv4) { + return Transaction.execute(new TransactionCallback() { + @Override + public VlanVO doInTransaction(final TransactionStatus status) { + VlanVO vlanRange = _vlanDao.findById(id); + s_logger.debug("Updating vlan range " + vlanRange.getId()); + vlanRange.setIpRange(vlanRange.getIpRange().replace(currentStartIP+"-", newStartIP+"-").replace(currentEndIP, + newEndIP)); + _vlanDao.update(vlanRange.getId(), vlanRange); + + final boolean isRangeForSystemVM = checkIfVlanRangeIsForSystemVM(id); + if (ipv4) { + if (!updatePublicIPRange(newStartIP,currentStartIP,newEndIP,currentEndIP,vlanRange.getDataCenterId(),vlanRange.getId(), vlanRange.getNetworkId(), vlanRange.getPhysicalNetworkId(), isRangeForSystemVM)) { + throw new CloudRuntimeException("Failed to update IPv4 range. Please contact Cloud Support."); + } + } + return vlanRange; + } + }); + + } + private boolean checkIfVlanRangeIsForSystemVM(final long vlanId) { + List existingPublicIPs = _publicIpAddressDao.listByVlanId(vlanId); + boolean initialIsSystemVmValue = existingPublicIPs.get(0).isForSystemVms(); + for(IPAddressVO existingIPs : existingPublicIPs){ + if(initialIsSystemVmValue != existingIPs.isForSystemVms()){ + throw new CloudRuntimeException("Your \"For System VM\" value seems to be inconsistent with the rest of the recods. Please contact Cloud Support"); + } + } + return initialIsSystemVmValue; + } + + private void checkAllocatedIpsAreWithinVlanRange(List ips, String startIp, String endIp){ + // Check if the VLAN has any allocated public IPs + List listAllocatedIPs = new ArrayList<>(); + for (final IPAddressVO ip : ips) { + if (ip.getState()== IpAddress.State.Allocated){ + listAllocatedIPs.add(ip); + } + } + Collections.sort(listAllocatedIPs, Comparator.comparing(IPAddressVO::getAddress)); + for (IPAddressVO allocatedIP : listAllocatedIPs){ + if (!Strings.isNullOrEmpty(startIp) && NetUtils.ip2Long(startIp) > NetUtils.ip2Long(allocatedIP.getAddress().addr())) { + throw new InvalidParameterValueException("The start IP address must have a lower IP address value " + + "than "+ allocatedIP.getAddress() + " which is already in use. The end IP must have a " + + "higher IP address than "+ listAllocatedIPs.get(listAllocatedIPs.size() - 1).getAddress()+" .IPs " + + "already allocated in this range: "+listAllocatedIPs.size()); + } + if (!Strings.isNullOrEmpty(endIp) && NetUtils.ip2Long(endIp) < NetUtils.ip2Long(allocatedIP.getAddress().addr())) { + throw new InvalidParameterValueException("The start IP address must have a lower IP address value " + + "than "+ listAllocatedIPs.get(0).getAddress() + " which is already in use. The end IP must have a " + + "higher IP address than "+ allocatedIP.getAddress()+" .IPs " + + "already allocated in this range: "+listAllocatedIPs.size()); + } + } + } + + private void checkGatewayOverlap(String startIp, String endIp, String gateway){ + if (NetUtils.ipRangesOverlap(startIp, endIp, gateway, gateway)) { + throw new InvalidParameterValueException("The gateway shouldn't overlap the new start/end ip " + + "addresses"); + } + } + @Override @DB public boolean deleteVlanAndPublicIpRange(final long userId, final long vlanDbId, final Account caller) { @@ -4404,6 +4560,51 @@ public List doInTransaction(final TransactionStatus status) { return problemIps != null && problemIps.size() == 0; } + @DB + protected boolean updatePublicIPRange(final String newStartIP, final String currentStartIP,final String newEndIP,final String currentEndIP, final long zoneId, final long vlanDbId, final long sourceNetworkid, final long physicalNetworkId, final boolean forSystemVms) { + long newStartIPLong = NetUtils.ip2Long(newStartIP); + long newEndIPLong = NetUtils.ip2Long(newEndIP); + long currentStartIPLong = NetUtils.ip2Long(currentStartIP); + long currentEndIPLong = NetUtils.ip2Long(currentEndIP); + + List currentIPRange = new ArrayList<>(); + List newIPRange = new ArrayList<>(); + while (newStartIPLong<=newEndIPLong){ + newIPRange.add(newStartIPLong); + newStartIPLong++; + } + while (currentStartIPLong<=currentEndIPLong){ + currentIPRange.add(currentStartIPLong); + currentStartIPLong++; + } + + final List problemIps= Transaction.execute(new TransactionCallback>() { + + @Override + public List doInTransaction(final TransactionStatus status) { + final IPRangeConfig config = new IPRangeConfig(); + Vector configResult = new Vector<>(); + List iPAddressesToAdd = new ArrayList(newIPRange); + iPAddressesToAdd.removeAll(currentIPRange); + if (iPAddressesToAdd.size()>0){ + for(Long startIP : iPAddressesToAdd){ + configResult= config.savePublicIPRange(TransactionLegacy.currentTxn(), startIP, startIP, zoneId, vlanDbId, sourceNetworkid, physicalNetworkId, forSystemVms); + } + }else { + currentIPRange.removeAll(newIPRange); + if(currentIPRange.size()>0){ + for (Long startIP: currentIPRange){ + configResult= config.deletePublicIPRange(TransactionLegacy.currentTxn(), startIP, startIP, vlanDbId); + } + } + + } + return configResult; + } + }); + return problemIps != null && problemIps.size() == 0; + } + private void checkPublicIpRangeErrors(final long zoneId, final String vlanId, final String vlanGateway, final String vlanNetmask, final String startIP, final String endIP) { // Check that the start and end IPs are valid if (!NetUtils.isValidIp4(startIP)) { diff --git a/server/src/main/java/com/cloud/server/ManagementServerImpl.java b/server/src/main/java/com/cloud/server/ManagementServerImpl.java index a3e9bb655940..73a87bf88e38 100644 --- a/server/src/main/java/com/cloud/server/ManagementServerImpl.java +++ b/server/src/main/java/com/cloud/server/ManagementServerImpl.java @@ -242,6 +242,7 @@ import org.apache.cloudstack.api.command.admin.vlan.DeleteVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.ListVlanIpRangesCmd; import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd; +import org.apache.cloudstack.api.command.admin.vlan.UpdateVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.vm.AddNicToVMCmdByAdmin; import org.apache.cloudstack.api.command.admin.vm.AssignVMCmd; import org.apache.cloudstack.api.command.admin.vm.DeployVMCmdByAdmin; @@ -2784,6 +2785,7 @@ public List> getCommands() { cmdList.add(RegisterCmd.class); cmdList.add(UpdateUserCmd.class); cmdList.add(CreateVlanIpRangeCmd.class); + cmdList.add(UpdateVlanIpRangeCmd.class); cmdList.add(DeleteVlanIpRangeCmd.class); cmdList.add(ListVlanIpRangesCmd.class); cmdList.add(DedicatePublicIpRangeCmd.class); diff --git a/server/src/main/java/com/cloud/test/IPRangeConfig.java b/server/src/main/java/com/cloud/test/IPRangeConfig.java index f35989102dd1..4cd76d249bd7 100644 --- a/server/src/main/java/com/cloud/test/IPRangeConfig.java +++ b/server/src/main/java/com/cloud/test/IPRangeConfig.java @@ -313,9 +313,9 @@ protected Vector deleteIPRange(String type, long podId, long zoneId, lon return problemIPs; } - private Vector deletePublicIPRange(TransactionLegacy txn, long startIP, long endIP, long vlanDbId) { - String deleteSql = "DELETE FROM `cloud`.`user_ip_address` WHERE public_ip_address = ? AND vlan_id = ?"; - String isPublicIPAllocatedSelectSql = "SELECT * FROM `cloud`.`user_ip_address` WHERE public_ip_address = ? AND vlan_id = ?"; + public Vector deletePublicIPRange(TransactionLegacy txn, long startIP, long endIP, long vlanDbId) { + String deleteSql = "DELETE FROM `cloud`.`user_ip_address` WHERE public_ip_address = ? AND vlan_db_id = ?"; + String isPublicIPAllocatedSelectSql = "SELECT * FROM `cloud`.`user_ip_address` WHERE public_ip_address = ? AND vlan_db_id = ?"; Vector problemIPs = new Vector(); Connection conn = null; @@ -329,9 +329,9 @@ private Vector deletePublicIPRange(TransactionLegacy txn, long startIP, try(PreparedStatement stmt = conn.prepareStatement(deleteSql); PreparedStatement isAllocatedStmt = conn.prepareStatement(isPublicIPAllocatedSelectSql);) { while (startIP <= endIP) { - if (!isPublicIPAllocated(startIP, vlanDbId, isAllocatedStmt)) { + if (!isPublicIPAllocated(NetUtils.long2Ip(startIP), vlanDbId, isAllocatedStmt)) { stmt.clearParameters(); - stmt.setLong(1, startIP); + stmt.setString(1, NetUtils.long2Ip(startIP)); stmt.setLong(2, vlanDbId); stmt.executeUpdate(); } @@ -379,21 +379,25 @@ private Vector deletePrivateIPRange(TransactionLegacy txn, long startIP, return problemIPs; } - private boolean isPublicIPAllocated(long ip, long vlanDbId, PreparedStatement stmt) { - try(ResultSet rs = stmt.executeQuery();) { - stmt.clearParameters(); - stmt.setLong(1, ip); - stmt.setLong(2, vlanDbId); - if (rs.next()) { - return (rs.getString("allocated") != null); - } else { - return false; - } - } - catch (SQLException ex) { - System.out.println(ex.getMessage()); - return true; - } + private boolean isPublicIPAllocated(String ip, long vlanDbId, PreparedStatement stmt) { + try{ + stmt.clearParameters(); + stmt.setString(1, ip); + stmt.setLong(2, vlanDbId); + try(ResultSet rs = stmt.executeQuery();) { + if (rs.next()) { + return (rs.getString("allocated") != null); + } else { + return false; + } + } + catch (SQLException ex) { + System.out.println(ex.getMessage()); + return true; + }}catch (SQLException ex) { + System.out.println(ex.getMessage()); + return true; + } } private boolean isPrivateIPAllocated(String ip, long podId, long zoneId, PreparedStatement stmt) { diff --git a/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java b/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java index b42996bb02b0..94b4ceae4398 100644 --- a/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java +++ b/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java @@ -44,6 +44,7 @@ import org.apache.cloudstack.api.command.admin.vlan.DedicatePublicIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.DeleteVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.vlan.ReleasePublicIpRangeCmd; +import org.apache.cloudstack.api.command.admin.vlan.UpdateVlanIpRangeCmd; import org.apache.cloudstack.api.command.admin.zone.CreateZoneCmd; import org.apache.cloudstack.api.command.admin.zone.DeleteZoneCmd; import org.apache.cloudstack.api.command.admin.zone.UpdateZoneCmd; @@ -258,6 +259,17 @@ public Vlan createVlanAndPublicIpRange(CreateVlanIpRangeCmd cmd) throws Insuffic return null; } + /* (non-Javadoc) + * @see com.cloud.configuration.ConfigurationService#updateVlanAndPublicIpRange(org.apache.cloudstack.api + * .commands.UpdateVlanIpRangeCmd) + */ + @Override + public Vlan updateVlanAndPublicIpRange(UpdateVlanIpRangeCmd cmd) throws ConcurrentOperationException, + ResourceUnavailableException, ResourceAllocationException{ + // TODO Auto-generated method stub + return null; + } + /* (non-Javadoc) * @see com.cloud.configuration.ConfigurationService#markDefaultZone(java.lang.String, long, long) */ From aa1650bb85273164b018a923d6d3017ef884af6d Mon Sep 17 00:00:00 2001 From: kioie Date: Sun, 29 Mar 2020 09:41:59 +0300 Subject: [PATCH 2/9] Edited ConfigurationManagerImpl --- .../com/cloud/configuration/ConfigurationManagerImpl.java | 8 -------- 1 file changed, 8 deletions(-) diff --git a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java index a2c9c8e79ab3..362fb73c81ef 100755 --- a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java +++ b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java @@ -26,10 +26,7 @@ import java.util.Arrays; import java.util.Collection; import java.util.Collections; -<<<<<<< HEAD:server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java -======= import java.util.Comparator; ->>>>>>> Added Logic to update the user_ip_address table:server/src/com/cloud/configuration/ConfigurationManagerImpl.java import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; @@ -43,13 +40,8 @@ import javax.inject.Inject; import javax.naming.ConfigurationException; - -<<<<<<< HEAD:server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java -======= import com.cloud.network.IpAddress; import com.google.common.collect.Sets; - ->>>>>>> Added Logic to update the user_ip_address table:server/src/com/cloud/configuration/ConfigurationManagerImpl.java import org.apache.cloudstack.acl.SecurityChecker; import org.apache.cloudstack.affinity.AffinityGroup; import org.apache.cloudstack.affinity.AffinityGroupService; From 5d572bbeb88a236b840048d511c3e16e949a775c Mon Sep 17 00:00:00 2001 From: kioie Date: Mon, 6 Jul 2020 13:06:21 +0300 Subject: [PATCH 3/9] Refactor UpdateVlanIpRangeCmd location --- .../cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename api/src/{ => main/java}/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java (100%) diff --git a/api/src/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java similarity index 100% rename from api/src/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java rename to api/src/main/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java From 0a76ff467a6d3843e20da138707ab87ba448aedc Mon Sep 17 00:00:00 2001 From: kioie Date: Mon, 13 Jul 2020 13:44:16 +0300 Subject: [PATCH 4/9] Checkstyle corrections --- .../ConfigurationManagerImpl.java | 66 ++++++++++--------- .../java/com/cloud/test/IPRangeConfig.java | 21 +++--- 2 files changed, 45 insertions(+), 42 deletions(-) diff --git a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java index 362fb73c81ef..45d783713c63 100755 --- a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java +++ b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java @@ -40,8 +40,7 @@ import javax.inject.Inject; import javax.naming.ConfigurationException; -import com.cloud.network.IpAddress; -import com.google.common.collect.Sets; + import org.apache.cloudstack.acl.SecurityChecker; import org.apache.cloudstack.affinity.AffinityGroup; import org.apache.cloudstack.affinity.AffinityGroupService; @@ -165,6 +164,7 @@ import com.cloud.gpu.GPU; import com.cloud.host.dao.HostDao; import com.cloud.hypervisor.Hypervisor.HypervisorType; +import com.cloud.network.IpAddress; import com.cloud.network.IpAddressManager; import com.cloud.network.Network; import com.cloud.network.Network.Capability; @@ -1775,7 +1775,6 @@ private void checkZoneParameters(final String zoneName, final String dns1, final } } - private void checkIpRange(final String startIp, final String endIp, final String cidrAddress, final long cidrSize) { //Checking not null for start IP as well. Previously we assumed to be not null always. //But the check is required for the change in updatePod API. @@ -4082,7 +4081,7 @@ public VlanVO doInTransaction(final TransactionStatus status) { @Override public Vlan updateVlanAndPublicIpRange(UpdateVlanIpRangeCmd cmd) throws ConcurrentOperationException, - ResourceUnavailableException,ResourceAllocationException{ + ResourceUnavailableException,ResourceAllocationException { return updateVlanAndPublicIpRange(cmd.getId(), cmd.getStartIp(),cmd.getEndIp(), cmd.getGateway(),cmd.getNetmask()); @@ -4094,7 +4093,7 @@ public Vlan updateVlanAndPublicIpRange(UpdateVlanIpRangeCmd cmd) throws Concurre public Vlan updateVlanAndPublicIpRange(final long id, String startIp, String endIp, String gateway, - String netmask) throws ConcurrentOperationException{ + String netmask) throws ConcurrentOperationException { VlanVO vlanRange = _vlanDao.findById(id); if (vlanRange == null) { @@ -4110,15 +4109,15 @@ public Vlan updateVlanAndPublicIpRange(final long id, String startIp, } final String[] existingVlanIPRangeArray = vlanRange.getIpRange().split("-"); - final String currentStartIP= existingVlanIPRangeArray[0]; + final String currentStartIP = existingVlanIPRangeArray[0]; final String currentEndIP = existingVlanIPRangeArray [1]; - if(startIp == null){ - startIp= currentStartIP; + if(startIp == null) { + startIp = currentStartIP; } - if(endIp == null){ - endIp= currentEndIP; + if(endIp == null) { + endIp = currentEndIP; } final List ips = _publicIpAddressDao.listByVlanId(id); @@ -4136,8 +4135,8 @@ public Vlan updateVlanAndPublicIpRange(final long id, String startIp, VlanVO range; try { - final String newStartIP= startIp; - final String newEndIP= endIp; + final String newStartIP = startIp; + final String newEndIP = endIp; range = _vlanDao.acquireInLockTable(id, 30); if (range == null) { @@ -4153,19 +4152,20 @@ public Vlan updateVlanAndPublicIpRange(final long id, String startIp, } catch (final Exception e) { s_logger.error("Unable to edit VlanRange due to " + e.getMessage(), e); throw new CloudRuntimeException("Failed to edit VlanRange. Please contact Cloud Support."); - }finally { + } finally { _vlanDao.releaseFromLockTable(id); } return vlanRange; } private VlanVO commitUpdateVlanAndIpRange(final Long id, final String newStartIP, final String newEndIP,final String currentStartIP, final String currentEndIP, final boolean ipv4) { + return Transaction.execute(new TransactionCallback() { @Override public VlanVO doInTransaction(final TransactionStatus status) { VlanVO vlanRange = _vlanDao.findById(id); s_logger.debug("Updating vlan range " + vlanRange.getId()); - vlanRange.setIpRange(vlanRange.getIpRange().replace(currentStartIP+"-", newStartIP+"-").replace(currentEndIP, + vlanRange.setIpRange(vlanRange.getIpRange().replace(currentStartIP + "-" , newStartIP + "-" ).replace(currentEndIP, newEndIP)); _vlanDao.update(vlanRange.getId(), vlanRange); @@ -4180,46 +4180,47 @@ public VlanVO doInTransaction(final TransactionStatus status) { }); } + private boolean checkIfVlanRangeIsForSystemVM(final long vlanId) { List existingPublicIPs = _publicIpAddressDao.listByVlanId(vlanId); boolean initialIsSystemVmValue = existingPublicIPs.get(0).isForSystemVms(); - for(IPAddressVO existingIPs : existingPublicIPs){ - if(initialIsSystemVmValue != existingIPs.isForSystemVms()){ + for (IPAddressVO existingIPs : existingPublicIPs) { + if (initialIsSystemVmValue != existingIPs.isForSystemVms()) { throw new CloudRuntimeException("Your \"For System VM\" value seems to be inconsistent with the rest of the recods. Please contact Cloud Support"); } } return initialIsSystemVmValue; } - private void checkAllocatedIpsAreWithinVlanRange(List ips, String startIp, String endIp){ - // Check if the VLAN has any allocated public IPs + private void checkAllocatedIpsAreWithinVlanRange(List ips, String startIp, String endIp) { + List listAllocatedIPs = new ArrayList<>(); for (final IPAddressVO ip : ips) { - if (ip.getState()== IpAddress.State.Allocated){ + if (ip.getState() == IpAddress.State.Allocated) { listAllocatedIPs.add(ip); } } Collections.sort(listAllocatedIPs, Comparator.comparing(IPAddressVO::getAddress)); - for (IPAddressVO allocatedIP : listAllocatedIPs){ + for (IPAddressVO allocatedIP : listAllocatedIPs) { if (!Strings.isNullOrEmpty(startIp) && NetUtils.ip2Long(startIp) > NetUtils.ip2Long(allocatedIP.getAddress().addr())) { - throw new InvalidParameterValueException("The start IP address must have a lower IP address value " + - "than "+ allocatedIP.getAddress() + " which is already in use. The end IP must have a " + - "higher IP address than "+ listAllocatedIPs.get(listAllocatedIPs.size() - 1).getAddress()+" .IPs " + - "already allocated in this range: "+listAllocatedIPs.size()); + throw new InvalidParameterValueException("The start IP address must have a lower IP address value " + + "than " + allocatedIP.getAddress() + " which is already in use. The end IP must have a " + + "higher IP address than " + listAllocatedIPs.get(listAllocatedIPs.size() - 1).getAddress() + " .IPs " + + "already allocated in this range: " + listAllocatedIPs.size()); } if (!Strings.isNullOrEmpty(endIp) && NetUtils.ip2Long(endIp) < NetUtils.ip2Long(allocatedIP.getAddress().addr())) { - throw new InvalidParameterValueException("The start IP address must have a lower IP address value " + - "than "+ listAllocatedIPs.get(0).getAddress() + " which is already in use. The end IP must have a " + - "higher IP address than "+ allocatedIP.getAddress()+" .IPs " + - "already allocated in this range: "+listAllocatedIPs.size()); + throw new InvalidParameterValueException("The start IP address must have a lower IP address value " + + "than " + listAllocatedIPs.get(0).getAddress() + " which is already in use. The end IP must have a " + + "higher IP address than " + allocatedIP.getAddress() + " .IPs " + + "already allocated in this range: " + listAllocatedIPs.size()); } } } - private void checkGatewayOverlap(String startIp, String endIp, String gateway){ + private void checkGatewayOverlap(String startIp, String endIp, String gateway) { if (NetUtils.ipRangesOverlap(startIp, endIp, gateway, gateway)) { - throw new InvalidParameterValueException("The gateway shouldn't overlap the new start/end ip " + - "addresses"); + throw new InvalidParameterValueException("The gateway shouldn't overlap the new start/end ip " + + "addresses"); } } @@ -4276,7 +4277,8 @@ public boolean deleteVlanAndPublicIpRange(final long userId, final long vlanDbId throw new InvalidParameterValueException("Can't delete account specific vlan " + vlanDbId + " as ip " + ip + " belonging to the range has firewall rules applied. Cleanup the rules first"); } - if (ip.getAllocatedTime() != null) {// This means IP is allocated + if (ip.getAllocatedTime() != null) { + // This means IP is allocated // release public ip address here success = _ipAddrMgr.disassociatePublicIpAddress(ip.getId(), userId, caller); } diff --git a/server/src/main/java/com/cloud/test/IPRangeConfig.java b/server/src/main/java/com/cloud/test/IPRangeConfig.java index 4cd76d249bd7..79843600967a 100644 --- a/server/src/main/java/com/cloud/test/IPRangeConfig.java +++ b/server/src/main/java/com/cloud/test/IPRangeConfig.java @@ -323,10 +323,10 @@ public Vector deletePublicIPRange(TransactionLegacy txn, long startIP, l conn = txn.getConnection(); } catch (SQLException e) { - System.out.println("deletePublicIPRange. Exception: " +e.getMessage()); + System.out.println("deletePublicIPRange. Exception: " + e.getMessage()); return null; } - try(PreparedStatement stmt = conn.prepareStatement(deleteSql); + try (PreparedStatement stmt = conn.prepareStatement(deleteSql); PreparedStatement isAllocatedStmt = conn.prepareStatement(isPublicIPAllocatedSelectSql);) { while (startIP <= endIP) { if (!isPublicIPAllocated(NetUtils.long2Ip(startIP), vlanDbId, isAllocatedStmt)) { @@ -334,14 +334,14 @@ public Vector deletePublicIPRange(TransactionLegacy txn, long startIP, l stmt.setString(1, NetUtils.long2Ip(startIP)); stmt.setLong(2, vlanDbId); stmt.executeUpdate(); - } + } else { problemIPs.add(NetUtils.long2Ip(startIP)); } startIP += 1; } - }catch (Exception ex) { - System.out.println("deletePublicIPRange. Exception: " +ex.getMessage()); + } catch (Exception ex) { + System.out.println("deletePublicIPRange. Exception: " + ex.getMessage()); return null; } @@ -372,7 +372,7 @@ private Vector deletePrivateIPRange(TransactionLegacy txn, long startIP, System.out.println("deletePrivateIPRange. Exception: " + e.getMessage()); printError("deletePrivateIPRange. Exception: " + e.getMessage()); } - }catch (SQLException e) { + } catch (SQLException e) { System.out.println("deletePrivateIPRange. Exception: " + e.getMessage()); printError("deletePrivateIPRange. Exception: " + e.getMessage()); } @@ -380,21 +380,22 @@ private Vector deletePrivateIPRange(TransactionLegacy txn, long startIP, } private boolean isPublicIPAllocated(String ip, long vlanDbId, PreparedStatement stmt) { - try{ + try { stmt.clearParameters(); stmt.setString(1, ip); stmt.setLong(2, vlanDbId); - try(ResultSet rs = stmt.executeQuery();) { + try (ResultSet rs = stmt.executeQuery()) { if (rs.next()) { return (rs.getString("allocated") != null); } else { return false; } - } + } catch (SQLException ex) { System.out.println(ex.getMessage()); return true; - }}catch (SQLException ex) { + } + } catch (SQLException ex) { System.out.println(ex.getMessage()); return true; } From a49dc954e8ca249946085af48a7107c8549c2d98 Mon Sep 17 00:00:00 2001 From: kioie Date: Mon, 13 Jul 2020 18:27:46 +0300 Subject: [PATCH 5/9] Mock updateVlanAndPublicIpRange --- .../java/com/cloud/vpc/MockConfigurationManagerImpl.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java b/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java index 94b4ceae4398..0bf18233cb60 100644 --- a/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java +++ b/server/src/test/java/com/cloud/vpc/MockConfigurationManagerImpl.java @@ -514,6 +514,14 @@ public Vlan createVlanAndPublicIpRange(long zoneId, long networkId, long physica return null; } + /* (non-Javadoc) + * @see com.cloud.configuration.ConfigurationManager#updateVlanAndPublicIpRange(long, java.lang.String, java.lang.String, java.lang.String, java.lang.String) + */ + @Override + public Vlan updateVlanAndPublicIpRange(long id, String startIp, String endIp, String gateway, String netmask) throws ConcurrentOperationException { + return null; + } + /* (non-Javadoc) * @see com.cloud.configuration.ConfigurationManager#createDefaultSystemNetworks(long) */ From d5ee6b991b2a9845bd6695d4d94be1e05b9db9ab Mon Sep 17 00:00:00 2001 From: kioie Date: Thu, 22 Oct 2020 08:06:32 +0300 Subject: [PATCH 6/9] Changes: UpdateVlanIpRangeCmd - changed since to 4.15.0 ConfigurationService - updated Javadoc ConfigurationManager - Updated Javadoc --- .../configuration/ConfigurationService.java | 16 +++++----------- .../command/admin/vlan/UpdateVlanIpRangeCmd.java | 2 +- .../configuration/ConfigurationManager.java | 11 +++++++++-- 3 files changed, 15 insertions(+), 14 deletions(-) diff --git a/api/src/main/java/com/cloud/configuration/ConfigurationService.java b/api/src/main/java/com/cloud/configuration/ConfigurationService.java index 98fea0ecab77..39b4c9898e7f 100644 --- a/api/src/main/java/com/cloud/configuration/ConfigurationService.java +++ b/api/src/main/java/com/cloud/configuration/ConfigurationService.java @@ -274,18 +274,12 @@ Vlan createVlanAndPublicIpRange(CreateVlanIpRangeCmd cmd) throws InsufficientCap ResourceAllocationException; /** - * Updates the IP address Range for the VLAN on the database, a - * + * Updates the IP address Range for the VLAN on the database * @param cmd - * @param vlanId - * @param gateway - * @param startIP - * @param endIP - * @param netmask - * @throws com.cloud.exception.ConcurrentOperationException - * @throws com.cloud.exception.ResourceUnavailableException - * @throws com.cloud.exception.ResourceAllocationException - * @return The updated Vlan object + * @return + * @throws ConcurrentOperationException + * @throws ResourceUnavailableException + * @throws ResourceAllocationException */ Vlan updateVlanAndPublicIpRange(UpdateVlanIpRangeCmd cmd) throws ConcurrentOperationException, ResourceUnavailableException, ResourceAllocationException; diff --git a/api/src/main/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java index b5e6aff42cd4..1b763406613d 100644 --- a/api/src/main/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java +++ b/api/src/main/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmd.java @@ -35,7 +35,7 @@ import com.cloud.utils.net.NetUtils; @APICommand(name = UpdateVlanIpRangeCmd.APINAME, description = "Updates a VLAN IP range.", responseObject = - VlanIpRangeResponse.class, since = "4.13.0", + VlanIpRangeResponse.class, since = "4.15.0", requestHasSensitiveInfo = false, responseHasSensitiveInfo = false) public class UpdateVlanIpRangeCmd extends BaseAsyncCmd { diff --git a/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java b/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java index 3fc5ab42c122..5e36a796fd43 100644 --- a/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java +++ b/engine/components-api/src/main/java/com/cloud/configuration/ConfigurationManager.java @@ -220,8 +220,15 @@ Vlan createVlanAndPublicIpRange(long zoneId, long networkId, long physicalNetwor String vlanGateway, String vlanNetmask, String vlanId, boolean bypassVlanOverlapCheck, Domain domain, Account vlanOwner, String startIPv6, String endIPv6, String vlanIp6Gateway, String vlanIp6Cidr) throws InsufficientCapacityException, ConcurrentOperationException, InvalidParameterValueException; - /* (non-Javadoc) - * @see com.cloud.configuration.ConfigurationManager#updateVlanAndPublicIpRange(long,String,String,String,String) + /** + * Updates the IP address Range for the VLAN and the Public IP + * @param id + * @param startIp + * @param endIp + * @param gateway + * @param netmask + * @return + * @throws ConcurrentOperationException */ Vlan updateVlanAndPublicIpRange(long id, String startIp, String endIp, String gateway, String netmask) throws ConcurrentOperationException; From a765191602fe972f311f0cabe14b7fefc688b33b Mon Sep 17 00:00:00 2001 From: kioie Date: Fri, 23 Oct 2020 11:16:33 +0300 Subject: [PATCH 7/9] Changes: Added Unit test --- .../configuration/ConfigurationService.java | 2 +- .../admin/vlan/UpdateVlanIpRangeCmdTest.java | 62 +++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java diff --git a/api/src/main/java/com/cloud/configuration/ConfigurationService.java b/api/src/main/java/com/cloud/configuration/ConfigurationService.java index 39b4c9898e7f..ee41fa7c2b84 100644 --- a/api/src/main/java/com/cloud/configuration/ConfigurationService.java +++ b/api/src/main/java/com/cloud/configuration/ConfigurationService.java @@ -276,7 +276,7 @@ Vlan createVlanAndPublicIpRange(CreateVlanIpRangeCmd cmd) throws InsufficientCap /** * Updates the IP address Range for the VLAN on the database * @param cmd - * @return + * @return The Updated Vlan Object * @throws ConcurrentOperationException * @throws ResourceUnavailableException * @throws ResourceAllocationException diff --git a/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java b/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java new file mode 100644 index 000000000000..41ba3debfe28 --- /dev/null +++ b/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java @@ -0,0 +1,62 @@ +package org.apache.cloudstack.api.command.admin.vlan; + +import junit.framework.TestCase; + +import org.apache.cloudstack.api.ResponseGenerator; +import org.apache.cloudstack.api.ServerApiException; +import org.apache.cloudstack.api.response.VlanIpRangeResponse; +import org.junit.Test; +import org.mockito.Mockito; + +import com.cloud.configuration.ConfigurationService; +import com.cloud.dc.Vlan; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; + +public class UpdateVlanIpRangeCmdTest extends TestCase { + + private UpdateVlanIpRangeCmd updateVlanIpRangeCmd; + private ResponseGenerator responseGenerator; + + @Test + public void testUpdateSuccess() throws Exception { + + ConfigurationService configService = Mockito.mock(ConfigurationService.class); + Vlan result = Mockito.mock(Vlan.class); + + responseGenerator = Mockito.mock(ResponseGenerator.class); + updateVlanIpRangeCmd = new UpdateVlanIpRangeCmd(); + + Mockito.when(configService.updateVlanAndPublicIpRange(updateVlanIpRangeCmd)).thenReturn(result); + updateVlanIpRangeCmd._configService = configService; + + VlanIpRangeResponse ipRes = Mockito.mock(VlanIpRangeResponse.class); + Mockito.when(responseGenerator.createVlanIpRangeResponse(result)).thenReturn(ipRes); + + updateVlanIpRangeCmd._responseGenerator = responseGenerator; + try { + updateVlanIpRangeCmd.execute(); + } catch (ServerApiException ex) { + assertEquals("Failed to Update vlan ip range", ex.getMessage()); + } + } + + @Test + public void testUpdateFailure() throws ResourceAllocationException, ResourceUnavailableException { + + ConfigurationService configService = Mockito.mock(ConfigurationService.class); + + responseGenerator = Mockito.mock(ResponseGenerator.class); + updateVlanIpRangeCmd = new UpdateVlanIpRangeCmd(); + updateVlanIpRangeCmd._configService = configService; + + Mockito.when(configService.updateVlanAndPublicIpRange(updateVlanIpRangeCmd)).thenReturn(null); + + try { + updateVlanIpRangeCmd.execute(); + } catch (ServerApiException ex) { + assertEquals("Failed to Update vlan ip range", ex.getMessage()); + } + + } +} \ No newline at end of file From 84828d4695da9f94dc8e496930c499119ca5d052 Mon Sep 17 00:00:00 2001 From: kioie Date: Fri, 23 Oct 2020 15:43:45 +0300 Subject: [PATCH 8/9] Add license --- .../admin/vlan/UpdateVlanIpRangeCmdTest.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java b/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java index 41ba3debfe28..280acbda6897 100644 --- a/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java +++ b/api/src/test/java/org/apache/cloudstack/api/command/admin/vlan/UpdateVlanIpRangeCmdTest.java @@ -1,3 +1,19 @@ +// 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 org.apache.cloudstack.api.command.admin.vlan; import junit.framework.TestCase; From 4d417ea57fd14bea873c04a7344bad1420d1f2ac Mon Sep 17 00:00:00 2001 From: dahn Date: Tue, 10 Nov 2020 21:26:07 +0100 Subject: [PATCH 9/9] Update server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java --- .../java/com/cloud/configuration/ConfigurationManagerImpl.java | 1 + 1 file changed, 1 insertion(+) diff --git a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java index 45d783713c63..f2718235310b 100755 --- a/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java +++ b/server/src/main/java/com/cloud/configuration/ConfigurationManagerImpl.java @@ -4158,6 +4158,7 @@ public Vlan updateVlanAndPublicIpRange(final long id, String startIp, return vlanRange; } + private VlanVO commitUpdateVlanAndIpRange(final Long id, final String newStartIP, final String newEndIP,final String currentStartIP, final String currentEndIP, final boolean ipv4) { return Transaction.execute(new TransactionCallback() {