*/
package org.opendaylight.vpnservice.neutronvpn;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
logger.info("Neutron VPN Manager Closed");
}
- protected Subnetmap updateSubnetNode(Uuid subnetId, Uuid tenantId, Uuid networkId, Uuid routerId, Uuid vpnId,
- Uuid portId) {
+ protected Subnetmap updateSubnetNode(Uuid subnetId, String subnetIp, Uuid tenantId, Uuid networkId, Uuid routerId,
+ Uuid vpnId, Uuid portId) {
Subnetmap subnetmap = null;
SubnetmapBuilder builder = null;
boolean isLockAcquired = false;
logger.debug("updating Subnet :new: ");
}
+ if (subnetIp != null) {
+ builder.setSubnetIp(subnetIp);
+ }
if (routerId != null) {
builder.setRouterId(routerId);
}
return subnetmap;
}
+ protected void deleteSubnetMapNode(Uuid subnetId) {
+ boolean isLockAcquired = false;
+ InstanceIdentifier<Subnetmap> subnetMapIdentifier = InstanceIdentifier.builder(Subnetmaps.class)
+ .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
+ logger.debug("removing subnetMap node: {} ", subnetId.getValue());
+ try {
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
+ MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
+ } catch (Exception e) {
+ logger.error("Delete subnetMap node failed for subnet : {} ", subnetId.getValue());
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
+ }
+ }
+ }
+
private void updateVpnInstanceNode(String vpnName, List<String> rd, List<String> irt, List<String> ert) {
VpnInstanceBuilder builder = null;
}
String portname = NeutronvpnUtils.uuidToTapPortName(port.getUuid());
List<Adjacency> adjList = new ArrayList<Adjacency>();
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(portname)).build();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(portname);
+
// find router associated to vpn
Uuid routerId = NeutronvpnUtils.getRouterforVpn(broker, vpnId);
Router rtr = null;
if (port != null) {
boolean isLockAcquired = false;
String pname = NeutronvpnUtils.uuidToTapPortName(port.getUuid());
- InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
- child(VpnInterface.class, new VpnInterfaceKey(pname)).build();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(pname);
+
try {
isLockAcquired = NeutronvpnUtils.lock(lockManager, pname);
logger.debug("Deleting vpn interface {}", pname);
}
}
+ protected void updateVpnInterface(Uuid vpnId, Port port) {
+ if (vpnId == null || port == null) {
+ return;
+ }
+ boolean isLockAcquired = false;
+ String portname = NeutronvpnUtils.uuidToTapPortName(port.getUuid());
+ String ifname = new StringBuilder(portname).append(":0").toString();
+ InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(ifname);
+ try {
+ Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
+ .CONFIGURATION, vpnIfIdentifier);
+ if (optionalVpnInterface.isPresent()) {
+ VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get());
+ VpnInterface vpnIf = vpnIfBuilder.setVpnInstanceName(vpnId.getValue()).build();
+ isLockAcquired = NeutronvpnUtils.lock(lockManager, ifname);
+ logger.debug("Updating vpn interface {}", vpnIf);
+ MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
+ } else {
+ logger.error("VPN Interface {} not found", ifname);
+ }
+ } catch (Exception ex) {
+ logger.error("Updation of vpninterface {} failed due to {}", ifname, ex);
+ } finally {
+ if (isLockAcquired) {
+ NeutronvpnUtils.unlock(lockManager, ifname);
+ }
+ }
+ }
+
public void createL3Vpn(Uuid vpn, String name, Uuid tenant, List<String> rd, List<String> irt, List<String> ert,
Uuid router, List<Uuid> networks) {
vpn.getImportRT(), vpn.getExportRT(), vpn.getRouterId(), vpn.getNetworkIds());
} catch (Exception ex) {
msg = String.format("Creation of L3VPN failed for VPN %s", vpn.getId().getValue());
- logger.error(msg, ex.getMessage());
+ logger.error(msg, ex);
error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
errorList.add(error);
failurecount++;
InstanceIdentifier.builder(VpnInstances.class).build();
Optional<VpnInstances> optionalVpns = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
vpnsIdentifier);
- if (optionalVpns.isPresent()) {
+ if (optionalVpns.isPresent() && optionalVpns.get().getVpnInstance() != null) {
for (VpnInstance vpn : optionalVpns.get().getVpnInstance()) {
vpns.add(vpn);
}
for (VpnInstance vpnInstance : vpns) {
Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
// create VpnMaps id
- InstanceIdentifier<VpnMap> vpnMapIdentifier =
- InstanceIdentifier.builder(VpnMaps.class)
- .child(VpnMap.class, new VpnMapKey(vpnId)).build();
+ InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap
+ .class, new VpnMapKey(vpnId)).build();
L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
List<String> rd = Arrays.asList(vpnInstance.getIpv4Family().getRouteDistinguisher().split(","));
} catch (Exception ex) {
String message = String.format("GetL3VPN failed due to %s", ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, message).build());
}
-
return result;
}
}
} catch (Exception ex) {
msg = String.format("Deletion of L3VPN failed when deleting for uuid %s", vpn.getValue());
- logger.error(msg, ex.getMessage());
+ logger.error(msg, ex);
error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
errorList.add(error);
failurecount++;
protected void addSubnetToVpn(Uuid vpnId, Uuid subnet) {
logger.debug("Adding subnet {} to vpn {}", subnet.getValue(), vpnId.getValue());
- Subnetmap sn = updateSubnetNode(subnet, null, null, null, vpnId, null);
+ Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
// Check if there are ports on this subnet and add corresponding vpn-interfaces
List<Uuid> portList = sn.getPortList();
if (portList != null) {
}
}
+ protected void updateVpnForSubnet(Uuid vpnId, Uuid subnet) {
+ logger.debug("Updating VPN {} for subnet {}", vpnId.getValue(), subnet.getValue());
+ Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
+ // Check for ports on this subnet and update association of corresponding vpn-interfaces to external vpn
+ List<Uuid> portList = sn.getPortList();
+ if (portList != null) {
+ for (Uuid port : sn.getPortList()) {
+ logger.debug("Updating vpn-interface for port {}", port.getValue());
+ updateVpnInterface(vpnId, getNeutronPort(port));
+ }
+ }
+ }
+
protected List<Adjacency> addAdjacencyforExtraRoute(List<Routes> routeList, boolean rtrUp, String vpnifname) {
List<Adjacency> adjList = new ArrayList<Adjacency>();
for (Routes route : routeList) {
}
protected void associateRouterToVpn(Uuid vpnId, Uuid routerId) {
-
+ updateVpnMaps(vpnId, null, routerId, null, null);
List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
-
if (!vpnId.equals(routerId)) {
- logger.debug("Removing subnets from internal vpn {}", routerId.getValue());
+ logger.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
if (routerSubnets != null) {
- for (Uuid subnet : routerSubnets) {
- removeSubnetFromVpn(routerId, subnet);
+ for (Uuid subnetId : routerSubnets) {
+ updateVpnForSubnet(vpnId, subnetId);
}
}
+ } else {
+ logger.debug("Adding subnets to internal vpn {}", vpnId.getValue());
+ for (Uuid subnet : routerSubnets) {
+ addSubnetToVpn(vpnId, subnet);
+ }
}
- logger.debug("Adding subnets to vpn {}", vpnId.getValue());
- for (Uuid subnet : routerSubnets) {
- addSubnetToVpn(vpnId, subnet);
- }
-
- updateVpnMaps(vpnId, null, routerId, null, null);
}
protected void dissociateRouterFromVpn(Uuid vpnId, Uuid routerId) {
- // remove existing external vpn interfaces
List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
-
if (routerSubnets != null) {
- for (Uuid subnet : routerSubnets) {
- logger.debug("Removing subnets from external vpn {}", vpnId.getValue());
- removeSubnetFromVpn(vpnId, subnet);
- logger.debug("Adding subnets to internal vpn {}", routerId.getValue());
- addSubnetToVpn(routerId, subnet);
+ for (Uuid subnetId : routerSubnets) {
+ logger.debug("Updating association of subnets to internal vpn {}", routerId.getValue());
+ updateVpnForSubnet(routerId, subnetId);
}
}
clearFromVpnMaps(vpnId, routerId, null);
} catch (Exception ex) {
String message = String.format("associate Networks to vpn %s failed due to %s", input.getVpnId().getValue(),
ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<AssociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
.build());
}
} catch (Exception ex) {
String message = String.format("associate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
}
logger.debug("associateRouter returns..");
returnMsg.append("VPN not found : ").append(vpnId.getValue());
}
if (returnMsg.length() != 0) {
- String message = String.format("disssociate Networks to vpn %s failed due to %s", vpnId.getValue(),
+ String message = String.format("dissociate Networks to vpn %s failed due to %s", vpnId.getValue(),
returnMsg);
logger.error(message);
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
} catch (Exception ex) {
String message = String.format("dissociate Networks to vpn %s failed due to %s", input.getVpnId().
getValue(), ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<DissociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
.build());
}
returnMsg.append("VPN not found : ").append(vpnId.getValue());
}
if (returnMsg.length() != 0) {
- String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
+ String message = String.format("dissociate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), returnMsg);
logger.error(message);
String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
} catch (Exception ex) {
String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
vpnId.getValue(), ex.getMessage());
- logger.error(message);
+ logger.error(message, ex);
result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
}
logger.debug("dissociateRouter returns..");
InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
Optional<Subnetmaps> subnetmaps = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
subnetmapsid);
- if (subnetmaps.isPresent()) {
- Subnetmaps smaps = subnetmaps.get();
- List<Subnetmap> subnetMapList = smaps.getSubnetmap();
+ if (subnetmaps.isPresent() && subnetmaps.get().getSubnetmap() != null) {
+ List<Subnetmap> subnetMapList = subnetmaps.get().getSubnetmap();
for (Subnetmap subnetMap : subnetMapList) {
if (subnetMap.getVpnId() != null && subnetMap.getVpnId().equals(vpnid)) {
subnets.add(subnetMap.getId());
InstanceIdentifier<Ports> portidentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
try {
Optional<Ports> ports = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, portidentifier);
- if (ports.isPresent()) {
+ if (ports.isPresent() && ports.get().getPort()!= null) {
List<Port> portList = ports.get().getPort();
for (Port port : portList) {
result.add(String.format(" %-22s %-22s %-22s %-6s ", NeutronvpnUtils.uuidToTapPortName(port
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
+import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
protected static Uuid getVpnForNetwork(DataBroker broker, Uuid network) {
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION, vpnMapsIdentifier);
- if (optionalVpnMaps.isPresent()) {
- VpnMaps vpnMaps = optionalVpnMaps.get();
- List<VpnMap> allMaps = vpnMaps.getVpnMap();
+ if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
+ List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
for (VpnMap vpnMap : allMaps) {
if (vpnMap.getNetworkIds().contains(network)) {
return vpnMap.getVpnId();
InstanceIdentifier<VpnMaps> vpnMapsIdentifier = InstanceIdentifier.builder(VpnMaps.class).build();
Optional<VpnMaps> optionalVpnMaps = read(broker, LogicalDatastoreType.CONFIGURATION,
vpnMapsIdentifier);
- if (optionalVpnMaps.isPresent()) {
- VpnMaps vpnNets = optionalVpnMaps.get();
- List<VpnMap> allMaps = vpnNets.getVpnMap();
+ if (optionalVpnMaps.isPresent() && optionalVpnMaps.get().getVpnMap() != null) {
+ List<VpnMap> allMaps = optionalVpnMaps.get().getVpnMap();
if (routerId != null) {
for (VpnMap vpnMap : allMaps) {
if (routerId.equals(vpnMap.getRouterId())) {
protected static boolean lock(LockManagerService lockManager, String lockName) {
TryLockInput input = new TryLockInputBuilder().setLockName(lockName).setTime(5L).setTimeUnit
(TimeUnits.Milliseconds).build();
- boolean islockAquired = false;
+ boolean islockAcquired = false;
try {
Future<RpcResult<Void>> result = lockManager.tryLock(input);
if ((result != null) && (result.get().isSuccessful())) {
logger.debug("Acquired lock for {}", lockName);
- islockAquired = true;
+ islockAcquired = true;
} else {
- throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName));
+ logger.error("Unable to acquire lock for {}", lockName);
}
} catch (InterruptedException | ExecutionException e) {
logger.error("Unable to acquire lock for {}", lockName);
- throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e
- .getCause());
+ throw new RuntimeException(String.format("Unable to acquire lock for %s", lockName), e.getCause());
}
- return islockAquired;
+ return islockAcquired;
}
- protected static void unlock(LockManagerService lockManager, String lockName) {
+ protected static boolean unlock(LockManagerService lockManager, String lockName) {
UnlockInput input = new UnlockInputBuilder().setLockName(lockName).build();
+ boolean islockAcquired = false;
try {
Future<RpcResult<Void>> result = lockManager.unlock(input);
if ((result != null) && (result.get().isSuccessful())) {
logger.debug("Unlocked {}", lockName);
+ islockAcquired = true;
} else {
- logger.debug("Unable to unlock {}", lockName);
+ logger.error("Unable to unlock {}", lockName);
}
} catch (InterruptedException | ExecutionException e) {
logger.error("Unable to unlock {}", lockName);
- throw new RuntimeException(String.format("Unable to unlock %s", lockName), e
- .getCause());
+ throw new RuntimeException(String.format("Unable to unlock %s", lockName), e.getCause());
}
+ return islockAcquired;
}
protected static Short getIPPrefixFromPort(DataBroker broker, Port port) {
logger.trace("Unable to read on subnet datastore");
}
} catch (Exception e) {
- logger.trace("Failed to retrieve IP prefix from port : ", e);
+ logger.error("Failed to retrieve IP prefix from port : ", e);
System.out.println("Failed to retrieve IP prefix from port : " + e.getMessage());
}
return null;
return id;
}
+ static InstanceIdentifier<VpnInterface> buildVpnInterfaceIdentifier(String ifName) {
+ InstanceIdentifier<VpnInterface> id = InstanceIdentifier.builder(VpnInterfaces.class).
+ child(VpnInterface.class, new VpnInterfaceKey(ifName)).build();
+ return id;
+ }
+
static InstanceIdentifier<Subnetmap> buildSubnetMapIdentifier(Uuid subnetId) {
InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class, new
SubnetmapKey(subnetId)).build();
LOG.trace("VPN Interface already provisioned , bailing out from here.");
return;
}
-
bindService(dpId, vpnName, interfaceName, lPortTag);
updateDpnDbs(vpnName, interfaceName, true);
processVpnInterfaceAdjacencies(VpnUtil.getVpnInterfaceIdentifier(vpnInterface.getName()), vpnInterface, true);
}
@Override
- protected void update(InstanceIdentifier<VpnInterface> identifier,
- VpnInterface original, VpnInterface update) {
- LOG.trace("Update VPN Interface {} , original {}, update {}",
- identifier, original, update);
- String vpnName = original.getVpnInstanceName();
-
- boolean vpnNameChanged = false;
- String rd = getRouteDistinguisher(vpnName);
- String newRd = rd;
- String newVpnName = update.getVpnInstanceName();
- if(!vpnName.equals(newVpnName)) {
- //VPN for this interface got changed.
- //Remove the interface from old VPN and add it to new VPN
- newRd = getRouteDistinguisher(newVpnName);
- if(newRd.equals("")) {
- LOG.warn("VPN Instance {} not found. Update operation aborted", newVpnName);
- return;
- }
- vpnNameChanged = true;
- LOG.debug("New VPN Name for the interface {} is {}", newVpnName, original.getName());
+ protected void update(InstanceIdentifier<VpnInterface> identifier, VpnInterface original, VpnInterface update) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Updating VPN Interface : key " + identifier + ", original value=" + original + ", update " +
+ "value=" + update);
}
-
+ String oldVpnName = original.getVpnInstanceName();
+ String newVpnName = update.getVpnInstanceName();
List<Adjacency> oldAdjs = original.getAugmentation(Adjacencies.class).getAdjacency();
List<Adjacency> newAdjs = update.getAugmentation(Adjacencies.class).getAdjacency();
- if(vpnNameChanged && newAdjs != null && !newAdjs.isEmpty()) {
- long label = VpnConstants.INVALID_ID;
- InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, path);
- if (adjacencies.isPresent()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
- for(Adjacency nextHop : nextHops) {
- label = nextHop.getLabel();
- if(label == VpnConstants.INVALID_ID) {
- //Generate label using ID Manager
- label = VpnUtil.getUniqueId(idManager, VpnConstants.VPN_IDPOOL_NAME,
- VpnUtil.getNextHopLabelKey(newRd, nextHop.getIpAddress()));
- }
- if (rd != null) {
- removePrefixFromBGP(rd, nextHop.getIpAddress());
- } else {
- removeFibEntryFromDS(vpnName, nextHop.getIpAddress());
- }
- //updatePrefixToBGP(newRd, nextHop, nextHopIp, label);
- }
- processVpnInterfaceAdjacencies(identifier, update, true);
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, identifier, update);
- }
- } else if (oldAdjs != newAdjs) {
- //handle both addition and removal of adjacencies
- //currently, new adjacency may be an extra route
+ if (oldAdjs == null) {
+ oldAdjs = new ArrayList<>();
+ }
+ if (newAdjs == null) {
+ newAdjs = new ArrayList<>();
+ }
+ //handles switching between <internal VPN - external VPN>
+ if (!oldVpnName.equals(newVpnName)) {
+ remove(identifier, original);
+ add(identifier, update);
+ }
+ //handle both addition and removal of adjacencies
+ //currently, new adjacency may be an extra route
+ if (!oldAdjs.equals(newAdjs)) {
for (Adjacency adj : newAdjs) {
if (oldAdjs.contains(adj)) {
oldAdjs.remove(adj);
addNewAdjToVpnInterface(identifier, adj);
}
}
-
for (Adjacency adj : oldAdjs) {
delAdjFromVpnInterface(identifier, adj);
}
}
- else {
- LOG.debug("No Update information is available for VPN Interface to proceed");
- }
-
}
public void processArpRequest(IpAddress srcIP, PhysAddress srcMac, IpAddress targetIP, String srcInterface){
Code Review / vpnservice.git / commitdiff