From 6e38655cce879c6631167b84c336956877191a05 Mon Sep 17 00:00:00 2001 From: Michal Cmarada Date: Thu, 13 Jul 2017 15:55:15 +0200 Subject: [PATCH] Fix metadata for route, arp and overlay Change-Id: Ibe038ebf494bdc744ce34d98dea5e26360de6676 Signed-off-by: Shakib Ahmed Signed-off-by: Michal Cmarada --- .../config/vpp_provider/impl/VppRenderer.java | 2 +- .../vpp/commands/StaticArpCommand.java | 8 +- .../renderer/vpp/lisp/LispStateManager.java | 3 + .../lisp/flat/overlay/FlatOverlayManager.java | 141 ++++++++++++++---- .../vpp/lisp/flat/overlay/RoutingInfo.java | 21 ++- .../flat/overlay/StaticRoutingHelper.java | 22 +-- .../vpp/lisp/loopback/LoopbackManager.java | 50 ++++--- .../HostIdToMetadataInterfaceMapper.java | 38 +++++ .../HostVrfRoutingInformationMapper.java | 15 +- ...a => InterfaceNameToStaticInfoMapper.java} | 11 +- .../vpp/lisp/util/ConfigManagerHelper.java | 31 ++++ .../vpp/policy/ForwardingManager.java | 14 +- .../vpp/policy/VppRendererPolicyManager.java | 80 +++++----- .../policy/VppRendererPolicyManagerTest.java | 2 +- 14 files changed, 321 insertions(+), 117 deletions(-) create mode 100644 renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java rename renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/{InterfaceNameToRouteInfoMapper.java => InterfaceNameToStaticInfoMapper.java} (85%) diff --git a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java index b0b0d0885..4926fcfc2 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java +++ b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java @@ -147,7 +147,7 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider { AclManager aclManager = new AclManager(mountDataProvider); NatManager natManager = new NatManager(dataBroker, mountDataProvider); LispStateManager lispStateManager = new LispStateManager(mountDataProvider); - FlatOverlayManager flatOverlayManager = new FlatOverlayManager(mountDataProvider); + FlatOverlayManager flatOverlayManager = new FlatOverlayManager(dataBroker, mountDataProvider); LoopbackManager loopbackManager = new LoopbackManager(mountDataProvider); subnetEventManager = new GbpSubnetEventManager(loopbackManager); dtoEventBus.register(interfaceManager); diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/commands/StaticArpCommand.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/commands/StaticArpCommand.java index 64204f063..e90bd2c7c 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/commands/StaticArpCommand.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/commands/StaticArpCommand.java @@ -33,15 +33,15 @@ public class StaticArpCommand extends AbstractConfigCommand{ private PhysAddress linkLayerAddress; private InterfaceKey interfaceKey; - public StaticArpCommand(NeighborCommandBuilder builder) { + public StaticArpCommand(StaticArpCommandBuilder builder) { this.operation = builder.getOperation(); this.ip = builder.getIp(); this.linkLayerAddress = builder.getLinkLayerAddress(); this.interfaceKey = builder.getInterfaceKey(); } - public static NeighborCommandBuilder builder() { - return new NeighborCommandBuilder(); + public static StaticArpCommandBuilder builder() { + return new StaticArpCommandBuilder(); } @Override @@ -78,7 +78,7 @@ public class StaticArpCommand extends AbstractConfigCommand{ .setLinkLayerAddress(this.linkLayerAddress); } - public static class NeighborCommandBuilder { + public static class StaticArpCommandBuilder { private General.Operations operation; private Ipv4AddressNoZone ip; private PhysAddress linkLayerAddress; diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java index 6e7dbf4cc..c6090e60e 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java @@ -67,6 +67,9 @@ public class LispStateManager { public synchronized void configureEndPoint(AddressEndpointWithLocation addressEp) { try { + if (lispStateHelper.isMetadataPort(addressEp)) { + return; + } DataBroker dataBroker = lispStateHelper.getPotentialExternalDataBroker(addressEp).get(); String hostName = lispStateHelper.getHostName(addressEp).get(); LispState lispStateOfNode = configureHostIfNeeded(hostName, dataBroker); diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java index 91d9c6edd..24c6d8bed 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java @@ -12,20 +12,27 @@ package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay; import com.google.common.base.Optional; import com.google.common.base.Preconditions; import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.StaticArpCommand; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostIdToMetadataInterfaceMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostVrfRoutingInformationMapper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.InterfaceNameToStaticInfoMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Routing; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.RoutingBuilder; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -41,21 +48,73 @@ public class FlatOverlayManager { private static final Logger LOG = LoggerFactory.getLogger(FlatOverlayManager.class); private ConfigManagerHelper overlayHelper; + private DataBroker dataBroker; private NeutronTenantToVniMapper neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance(); private HostVrfRoutingInformationMapper hostVrfInfo = HostVrfRoutingInformationMapper.getInstance(); + private HostIdToMetadataInterfaceMapper + hostIdToMetadataInterfaceMapper = HostIdToMetadataInterfaceMapper.getInstance(); + + private InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper; private StaticRoutingHelper staticRoutingHelper; - public FlatOverlayManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) { + public FlatOverlayManager(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) { this.overlayHelper = new ConfigManagerHelper(mountedDataBrokerProvider); - staticRoutingHelper = new StaticRoutingHelper(); + this.interfaceNameToStaticInfoMapper = InterfaceNameToStaticInfoMapper.getInstance(); + staticRoutingHelper = new StaticRoutingHelper(interfaceNameToStaticInfoMapper); + this.dataBroker = dataBroker; } public void configureEndpointForFlatOverlay(AddressEndpointWithLocation addressEp) { - configureInterfaceForFlatOverlay(addressEp); - addStaticArp(addressEp); - addStaticRoute(addressEp); + if (!overlayHelper.isMetadataPort(addressEp)) { + configureInterfaceForFlatOverlay(addressEp); + addStaticArp(addressEp); + addStaticRoute(addressEp); + } else { + Ipv4Address metadataIp = overlayHelper.getInterfaceIp(addressEp); + Ipv4Prefix metadataIpPrefix = overlayHelper.getInterfaceIpAsPrefix(addressEp); + addressEp.getRelativeLocations().getExternalLocation().forEach(externalLocation -> { + String hostName = overlayHelper.getHostName(externalLocation).get(); + String metadataInterfaceName = overlayHelper.getInterfaceName(externalLocation).get(); + + long vrf = getVni(addressEp.getTenant().getValue()); + + if (!hostIdToMetadataInterfaceMapper.isMetadataInterfaceConfigured(hostName, metadataInterfaceName)) { + DataBroker vppDataBroker = overlayHelper.getPotentialExternalDataBroker(externalLocation).get(); + addInterfaceInVrf(vppDataBroker, metadataInterfaceName, vrf); + String physicalAddress = resolvePhysicalAddress(hostName, metadataInterfaceName); + addStaticArp(vppDataBroker, hostName, metadataInterfaceName, physicalAddress, metadataIp); + addStaticRoute(vppDataBroker, hostName, vrf, metadataIp, metadataIpPrefix, metadataInterfaceName); + hostIdToMetadataInterfaceMapper.addMetadataInterfaceInHost(hostName, metadataInterfaceName); + } + }); + } + } + + private String resolvePhysicalAddress(String hostName, String metadataInterfaceName) { + String physAddress = null; + Optional configOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getVppRendererConfig(), + dataBroker.newReadOnlyTransaction()); + if (configOptional.isPresent() && configOptional.get().getVppEndpoint() != null) { + java.util.Optional vppEndpointOptional = configOptional.get().getVppEndpoint().stream() + .filter(vppEndpoint -> vppEndpoint.getVppNodeId().getValue().equals(hostName)) + .filter(vppEndpoint -> vppEndpoint.getVppInterfaceName().equals(metadataInterfaceName)) + .findFirst(); + if (vppEndpointOptional.isPresent() && vppEndpointOptional.get() + .getInterfaceTypeChoice() instanceof TapCase) { + TapCase tapCase = (TapCase) vppEndpointOptional.get().getInterfaceTypeChoice(); + physAddress = tapCase.getPhysicalAddress().getValue(); + LOG.trace("Resolved PhysicalAddress : {} for metadataInterfaceName: {}, on node: {}", physAddress + , metadataInterfaceName, hostName); + } else { + LOG.warn("PhysicalAddress was not resolved for metadataInterfaceName: {}, on node: {}", + metadataInterfaceName, hostName); + } + } + + return physAddress; } public void handleEndpointDeleteForFlatOverlay(AddressEndpointWithLocation addressEp) { @@ -74,10 +133,14 @@ public class FlatOverlayManager { Preconditions.checkArgument(interfaceNameOptional.isPresent()); - if (!putVrfInInterface(vppDataBroker, interfaceNameOptional.get(), vrf)) { - LOG.warn("Failed to put interface {} to vrf {}", interfaceNameOptional.get(), vrf); + addInterfaceInVrf(vppDataBroker, interfaceNameOptional.get(), vrf); + } + + private void addInterfaceInVrf(DataBroker vppDataBroker, String interfaceName, long vrf) { + if (!putVrfInInterface(vppDataBroker, interfaceName, vrf)) { + LOG.warn("Failed to put interface {} to vrf {}", interfaceName, vrf); } else { - LOG.debug("Added interface {} to vrf {}", interfaceNameOptional.get(), vrf); + LOG.debug("Added interface {} to vrf {}", interfaceName, vrf); } } @@ -99,32 +162,42 @@ public class FlatOverlayManager { Preconditions.checkArgument(interfaceNameOptional.isPresent()); String interfaceName = interfaceNameOptional.get(); - InterfaceKey interfaceKey = new InterfaceKey(interfaceName); - Ipv4AddressNoZone ip = new Ipv4AddressNoZone(overlayHelper.getInterfaceIp(addressEp)); + addStaticArp(vppDataBroker, hostName, interfaceName, physicalAddress, overlayHelper.getInterfaceIp(addressEp)); + } - if (!putIpv4Neighbor(vppDataBroker, interfaceKey, new PhysAddress(physicalAddress), ip)) { - LOG.warn("Failed to put static arp with interface {} for ip={} and physical-address={}", interfaceName, - ip, physicalAddress); + private void addStaticArp(DataBroker vppDataBroker, + String hostName, + String interfaceName, + String physicalAddress, + Ipv4Address ipv4Address) { + Ipv4AddressNoZone ip = new Ipv4AddressNoZone(ipv4Address); + InterfaceKey interfaceKey = new InterfaceKey(interfaceName); + if (!putStaticArp(vppDataBroker, + interfaceKey, + new PhysAddress(physicalAddress), + ip)) { + LOG.warn("Failed to put static arp with interface {} for ip={} and physical-address={}", + interfaceName, ip, physicalAddress); } else { LOG.debug("Added Static arp ({} {}) in host {} for interface {}", ip, physicalAddress, hostName, interfaceName); } } - private boolean putIpv4Neighbor(DataBroker vppDataBroker, + private boolean putStaticArp(DataBroker vppDataBroker, InterfaceKey interfaceKey, PhysAddress physAddress, Ipv4AddressNoZone ip) { - StaticArpCommand.NeighborCommandBuilder neighborCommandBuilder = new StaticArpCommand.NeighborCommandBuilder(); + StaticArpCommand.StaticArpCommandBuilder staticArpCommandBuilder = new StaticArpCommand.StaticArpCommandBuilder(); - neighborCommandBuilder.setOperation(General.Operations.PUT); - neighborCommandBuilder.setInterfaceKey(interfaceKey); - neighborCommandBuilder.setIp(ip); - neighborCommandBuilder.setLinkLayerAddress(physAddress); + staticArpCommandBuilder.setOperation(General.Operations.PUT); + staticArpCommandBuilder.setInterfaceKey(interfaceKey); + staticArpCommandBuilder.setIp(ip); + staticArpCommandBuilder.setLinkLayerAddress(physAddress); return GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker, - neighborCommandBuilder.build(), GbpNetconfTransaction.RETRY_COUNT); + staticArpCommandBuilder.build(), GbpNetconfTransaction.RETRY_COUNT); } private void addStaticRoute(AddressEndpointWithLocation addressEp) { @@ -134,27 +207,37 @@ public class FlatOverlayManager { long vni = getVni(addressEp.getTenant().getValue()); long vrf = vni; + String outgoingInterfaceName = overlayHelper.getInterfaceName(addressEp).get(); + Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp); + Ipv4Prefix ipv4Prefix = overlayHelper.getInterfaceIpAsPrefix(addressEp); + + addStaticRoute(vppDataBroker, hostName, vrf, ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName); + } + + private void addStaticRoute(DataBroker vppDataBroker, String hostName, long vrf, Ipv4Address ipWithoutPrefix, + Ipv4Prefix ipv4Prefix, String outgoingInterfaceName) { + if (!hostVrfInfo.vrfExists(hostName, vrf)) { if (!staticRoutingHelper.addRoutingProtocolForVrf(vppDataBroker, hostName, vrf)) { LOG.warn("Failed to add Routing protocol for host {} and vrf {}!", hostName, vrf); } } - String outgoingInterfaceName = overlayHelper.getInterfaceName(addressEp).get(); - Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp); - if (staticRoutingHelper.endPointRoutingExists(outgoingInterfaceName, ipWithoutPrefix)) { return; } - Ipv4Prefix ipv4Prefix = overlayHelper.getInterfaceIpAsPrefix(addressEp); + if (staticRoutingHelper.routeAlreadyExistsInHostVrf(hostName, vrf, ipWithoutPrefix)) { + LOG.warn("Ip already exists in host {} vrf {} ip {}", hostName, vrf, ipWithoutPrefix); + return; + } if (!staticRoutingHelper.addSingleStaticRouteInRoutingProtocol(vppDataBroker, - hostName, - vrf, - ipWithoutPrefix, - ipv4Prefix, - outgoingInterfaceName)) { + hostName, + vrf, + ipWithoutPrefix, + ipv4Prefix, + outgoingInterfaceName)) { LOG.warn("Failed to add routing ({} via {}) in vrf {} in compute host {}!", ipv4Prefix, outgoingInterfaceName, vrf, hostName); } else { diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java index 18853a928..3ca680083 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java @@ -7,12 +7,22 @@ */ package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; + +import java.util.HashSet; +import java.util.Set; + /** * Created by Shakib Ahmed on 5/4/17. */ public class RoutingInfo { private String ProtocolName; private int count = 0; + private Set allIpsInVrf; + + public RoutingInfo() { + allIpsInVrf = new HashSet<>(); + } public String getProtocolName() { return ProtocolName; @@ -26,7 +36,16 @@ public class RoutingInfo { return count; } - public void incrementCount() { + public void addIpInVrf(Ipv4Address ip) { + allIpsInVrf.add(ip); + incrementCount(); + } + + public boolean ipAlreadyExistsinVrf(Ipv4Address ip) { + return allIpsInVrf.contains(ip); + } + + private void incrementCount() { count++; } } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java index b438a9140..ca5d7b1b8 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java @@ -9,7 +9,7 @@ package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostVrfRoutingInformationMapper; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.InterfaceNameToRouteInfoMapper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.InterfaceNameToStaticInfoMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; @@ -48,10 +48,10 @@ public class StaticRoutingHelper { private HostVrfRoutingInformationMapper hostVrfInfo = HostVrfRoutingInformationMapper.getInstance(); - private InterfaceNameToRouteInfoMapper interfaceNameToRouteInfoMapper; + private InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper; - public StaticRoutingHelper() { - interfaceNameToRouteInfoMapper = new InterfaceNameToRouteInfoMapper(); + public StaticRoutingHelper(InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper) { + this.interfaceNameToStaticInfoMapper = interfaceNameToStaticInfoMapper; } public synchronized boolean addRoutingProtocolForVrf(DataBroker vppDataBroker, @@ -85,7 +85,11 @@ public class StaticRoutingHelper { } public boolean endPointRoutingExists(String interfaceName, Ipv4Address ip) { - return interfaceNameToRouteInfoMapper.routeAlreadyExists(interfaceName, ip); + return interfaceNameToStaticInfoMapper.routeAlreadyExists(interfaceName, ip); + } + + public boolean routeAlreadyExistsInHostVrf(String hostId, long vrf, Ipv4Address ip) { + return hostVrfInfo.ipAlreadyExistsInHostVrf(hostId, vrf, ip); } public synchronized boolean addSingleStaticRouteInRoutingProtocol(DataBroker vppDataBroker, @@ -117,8 +121,8 @@ public class StaticRoutingHelper { .child(Ipv4.class); if (GbpNetconfTransaction.netconfSyncedMerge(vppDataBroker, iid, ipv4Route, GbpNetconfTransaction.RETRY_COUNT)) { - interfaceNameToRouteInfoMapper.addRouteForInterface(outgoingInterface, nextHopAddress, routingId); - hostVrfInfo.addStaticRoute(hostId, vrf); + interfaceNameToStaticInfoMapper.addRouteForInterface(outgoingInterface, nextHopAddress, routingId); + hostVrfInfo.addStaticRoute(hostId, vrf, nextHopAddress); return true; } @@ -129,7 +133,7 @@ public class StaticRoutingHelper { String hostId, long vrf, String outgoingInterface) { - List allRoutingIdsForPort = interfaceNameToRouteInfoMapper.getRoutingIdsAssociatedWithInterface(outgoingInterface); + List allRoutingIdsForPort = interfaceNameToStaticInfoMapper.getRoutingIdsAssociatedWithInterface(outgoingInterface); boolean allOk = true; @@ -146,7 +150,7 @@ public class StaticRoutingHelper { } } - interfaceNameToRouteInfoMapper.clearStaticRoutesForInterface(outgoingInterface); + interfaceNameToStaticInfoMapper.clearStaticRoutesForInterface(outgoingInterface); return allOk; } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java index ba66a74c2..4a752da90 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java @@ -100,6 +100,12 @@ public class LoopbackManager { public void createSimpleLoopbackIfNeeded(AddressEndpointWithLocation addressEp) { try { + + if (loopbackManagerHelper.isMetadataPort(addressEp)) { + // if the address endpoint is a metadataport, no proxy arp range needed. + return; + } + DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get(); String hostName = loopbackManagerHelper.getHostName(addressEp).get(); String subnetUuid = loopbackManagerHelper.getSubnet(addressEp); @@ -133,11 +139,11 @@ public class LoopbackManager { } private void createLoopbackInterface(String hostName, String subnetUuid, DataBroker vppDataBroker, - LoopbackCommand loopbackCommand) throws LispConfigCommandFailedException { + LoopbackCommand loopbackCommand) throws LispConfigCommandFailedException { if (GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker, - loopbackCommand, - GbpNetconfTransaction.RETRY_COUNT)) { + loopbackCommand, + GbpNetconfTransaction.RETRY_COUNT)) { subnetHostSpecificInfo.addLoopbackForHost(hostName, subnetUuid, loopbackCommand.getName(), loopbackCommand.getVrfId()); subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid); @@ -201,16 +207,16 @@ public class LoopbackManager { Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix(); Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for " - + "subnet uuid =" + gbpSubnetInfo.getId() + "!"); + + "subnet uuid =" + gbpSubnetInfo.getId() + "!"); Pair startAndEndAddress = IpAddressUtil.getStartAndEndIp(subnetPrefix); if (!putArpRangesCommand(vppDataBroker, - vrf, - startAndEndAddress.getLeft(), - startAndEndAddress.getRight())) { + vrf, + startAndEndAddress.getLeft(), + startAndEndAddress.getRight())) { throw new LispConfigCommandFailedException("Proxy arp configuration failed for subnet uuid: " + - gbpSubnetInfo.getId() + "!"); + gbpSubnetInfo.getId() + "!"); } else { LOG.debug("Configured proxy arp for range {} to {} on node : {}!", startAndEndAddress.getLeft(), startAndEndAddress.getRight(), hostName); @@ -218,9 +224,9 @@ public class LoopbackManager { } private void deleteProxyArpRange(DataBroker vppDataBroker, - long vrf, - GbpSubnet gbpSubnetInfo, - String hostName) throws LispConfigCommandFailedException { + long vrf, + GbpSubnet gbpSubnetInfo, + String hostName) throws LispConfigCommandFailedException { Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix(); Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for " @@ -229,9 +235,9 @@ public class LoopbackManager { Pair startAndEndAddress = IpAddressUtil.getStartAndEndIp(subnetPrefix); if (!deleteArpRangesCommand(vppDataBroker, - vrf, - startAndEndAddress.getLeft(), - startAndEndAddress.getRight())) { + vrf, + startAndEndAddress.getLeft(), + startAndEndAddress.getRight())) { throw new LispConfigCommandFailedException("Proxy arp configuration failed for subnet uuid: " + gbpSubnetInfo.getId() + "!"); } else { @@ -248,8 +254,8 @@ public class LoopbackManager { builder.setEndAddress(end); return GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker, - builder.build(), - GbpNetconfTransaction.RETRY_COUNT); + builder.build(), + GbpNetconfTransaction.RETRY_COUNT); } private boolean deleteArpRangesCommand(DataBroker vppDataBroker, @@ -263,8 +269,8 @@ public class LoopbackManager { builder.setEndAddress(end); return GbpNetconfTransaction.netconfSyncedDelete(vppDataBroker, - builder.build(), - GbpNetconfTransaction.RETRY_COUNT); + builder.build(), + GbpNetconfTransaction.RETRY_COUNT); } private void addUnnumberedInterface(AddressEndpointWithLocation addressEp, String loopbackName) throws LispConfigCommandFailedException { @@ -299,8 +305,8 @@ public class LoopbackManager { .getSmallerSubnet(gbpSubnetInfo.getCidr().getIpv4Prefix()); RemoteEid firstREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getLeft()), - vni, - Ipv4PrefixAfi.class); + vni, + Ipv4PrefixAfi.class); putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1", firstREid, vni, vni); if (delegatingSubnets.getLeft().equals(delegatingSubnets.getRight())) { @@ -308,8 +314,8 @@ public class LoopbackManager { } RemoteEid secondREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getRight()), - vni, - Ipv4PrefixAfi.class); + vni, + Ipv4PrefixAfi.class); putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2", secondREid, vni, vni); } catch (LispHelperArgumentException e) { diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java new file mode 100644 index 000000000..8cd41eac8 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; + +import com.google.common.collect.HashMultimap; +import com.google.common.collect.SetMultimap; + + +/** + * Created by Shakib Ahmed on 7/10/17. + */ +public class HostIdToMetadataInterfaceMapper { + private SetMultimap hostIdToMetadataInterfaceNameMapper; + + private static final HostIdToMetadataInterfaceMapper INSTANCE = new HostIdToMetadataInterfaceMapper(); + + private HostIdToMetadataInterfaceMapper() { + hostIdToMetadataInterfaceNameMapper = HashMultimap.create(); + } + + public static HostIdToMetadataInterfaceMapper getInstance() { + return INSTANCE; + } + + public boolean isMetadataInterfaceConfigured(String hostId, String metadataInterfaceName) { + return hostIdToMetadataInterfaceNameMapper.get(hostId).contains(metadataInterfaceName); + } + + public void addMetadataInterfaceInHost(String hostId, String metadataInterfaceName) { + hostIdToMetadataInterfaceNameMapper.put(hostId, metadataInterfaceName); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java index 97d8834ba..2bcbb0481 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java @@ -11,6 +11,7 @@ package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; import com.google.common.base.Preconditions; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.RoutingInfo; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; import java.util.HashMap; @@ -51,7 +52,7 @@ public class HostVrfRoutingInformationMapper { return mapper.get(hostId).get(vrf).getProtocolName(); } - public void addStaticRoute(String hostId, long vrf) { + public void addStaticRoute(String hostId, long vrf, Ipv4Address ip) { HashMap routingInfoMapper = mapper.get(hostId); Preconditions.checkNotNull(routingInfoMapper, "Routing protocol not created, can't add route entry"); @@ -60,7 +61,7 @@ public class HostVrfRoutingInformationMapper { Preconditions.checkNotNull(routingInfoMapper, "VRF was not created for this host"); - routingInfo.incrementCount(); + routingInfo.addIpInVrf(ip); } public Long getEndPointCountInVrf(String hostId, long vrf) { @@ -71,4 +72,14 @@ public class HostVrfRoutingInformationMapper { } return (long) (count + 1); } + + public boolean ipAlreadyExistsInHostVrf(String hostId, long vrf, Ipv4Address ip) { + HashMap routingInfoMapper = mapper.get(hostId); + + Preconditions.checkNotNull(routingInfoMapper, "Routing protocol not created, can't add route entry"); + + RoutingInfo routingInfo = routingInfoMapper.get(vrf); + + return routingInfo.ipAlreadyExistsinVrf(ip); + } } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToRouteInfoMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToStaticInfoMapper.java similarity index 85% rename from renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToRouteInfoMapper.java rename to renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToStaticInfoMapper.java index f227684cd..39fdc5825 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToRouteInfoMapper.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToStaticInfoMapper.java @@ -7,6 +7,7 @@ */ package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; +import com.google.common.base.Preconditions; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; import java.util.ArrayList; @@ -16,13 +17,19 @@ import java.util.List; /** * Created by Shakib Ahmed on 5/26/17. */ -public class InterfaceNameToRouteInfoMapper { +public class InterfaceNameToStaticInfoMapper { HashMap interfaceNameToStaticRouteMapper; - public InterfaceNameToRouteInfoMapper() { + private static final InterfaceNameToStaticInfoMapper INSTANCE = new InterfaceNameToStaticInfoMapper(); + + private InterfaceNameToStaticInfoMapper() { interfaceNameToStaticRouteMapper = new HashMap<>(); } + public static InterfaceNameToStaticInfoMapper getInstance() { + return INSTANCE; + } + public boolean routeAlreadyExists(String interfaceName, Ipv4Address ip) { StaticRouteInfoMapper staticRouteInfoMapper = interfaceNameToStaticRouteMapper.get(interfaceName); diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java index b34e6c726..a23b5989f 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java @@ -39,6 +39,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpo import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.MacAddressType; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice; @@ -91,6 +92,17 @@ public class ConfigManagerHelper { return potentialVppDataProvider; } + public Optional getPotentialExternalDataBroker(ExternalLocation externalLocation) { + InstanceIdentifier vppNodeIid = externalLocation.getExternalNodeMountPoint(); + + Optional potentialVppDataProvider; + potentialVppDataProvider = mountedDataBrokerProvider.getDataBrokerForMountPoint(vppNodeIid); + + Preconditions.checkState(potentialVppDataProvider.isPresent(), "Data Broker missing"); + + return potentialVppDataProvider; + } + public Optional getPotentialExternalDataBroker(VppEndpoint vppEp) { InstanceIdentifier vppNodeIid = VppIidFactory.getNetconfNodeIid(vppEp.getVppNodeId()); Optional potentialVppDataProvider = @@ -117,7 +129,17 @@ public class ConfigManagerHelper { return Optional.fromNullable(hostId); } + public Optional getHostName(ExternalLocation externalLocation) { + NodeKey nodeKey = externalLocation.getExternalNodeMountPoint().firstKeyOf(Node.class); + String hostId = Preconditions.checkNotNull(nodeKey.getNodeId().getValue(), + "Host Id extraction failed from address endpoint: {}", externalLocation); + + return Optional.fromNullable(hostId); + } + public ExternalLocationCase resolveAndValidateLocation(AddressEndpointWithLocation addrEpWithLoc) { + Preconditions.checkNotNull(addrEpWithLoc.getAbsoluteLocation(), "Absolute location for " + + "AddressEndpointWithLocation missing: " + addrEpWithLoc.toString() ); LocationType locationType = addrEpWithLoc.getAbsoluteLocation().getLocationType(); if (!(locationType instanceof ExternalLocationCase)) { throw new IllegalArgumentException("Endpoint does not have external location " + addrEpWithLoc); @@ -295,6 +317,11 @@ public class ConfigManagerHelper { return VppPathMapper.interfacePathToInterfaceName(interfacePath); } + public Optional getInterfaceName(ExternalLocation externalLocation) { + String interfacePath = externalLocation.getExternalNodeConnector(); + return VppPathMapper.interfacePathToInterfaceName(interfacePath); + } + public HmacKey getDefaultHmacKey() { return LispUtil.toHmacKey(HmacKeyType.Sha196Key, LispStateManager.DEFAULT_XTR_KEY); } @@ -317,6 +344,10 @@ public class ConfigManagerHelper { "in address endpoint: " + addressEp); } + public boolean isMetadataPort(AddressEndpointWithLocation addedEp) { + return addedEp.getRelativeLocations() != null && addedEp.getRelativeLocations().getExternalLocation() != null; + } + public Routing getRouting(long vrf) { return new RoutingBuilder().setIpv4VrfId(vrf).build(); } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java index b8f404c73..b0ba5b0dd 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java @@ -211,12 +211,6 @@ public final class ForwardingManager { public void createForwardingForEndpoint(RendererEndpointKey rEpKey, PolicyContext policyCtx) { AddressEndpointWithLocation rEp = policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey)); - ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp); - if (Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) { - // TODO add it to the status for renderer manager - LOG.info("Renderer endpoint does not have external-node-connector therefore it is ignored {}", rEp); - return; - } if (ConfigUtil.getInstance().isLispOverlayEnabled()) { lispStateManager.configureEndPoint(rEp); if (ConfigUtil.getInstance().isL3FlatEnabled()) { @@ -224,6 +218,14 @@ public final class ForwardingManager { loopbackManager.createSimpleLoopbackIfNeeded(rEp); } } + + ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp); + if (rEpLoc == null || Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) { + // TODO add it to the status for renderer manager + LOG.info("Renderer endpoint does not have external-node-connector therefore it is ignored {}", rEp); + return; + } + if (Strings.isNullOrEmpty(rEpLoc.getExternalNode())) { java.util.Optional optL2FloodDomain = resolveL2FloodDomain(rEp, policyCtx); if (!optL2FloodDomain.isPresent()) { diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManager.java index 421073e74..59c67b103 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManager.java @@ -66,7 +66,7 @@ public class VppRendererPolicyManager { private final AclManager aclManager; public VppRendererPolicyManager(@Nonnull ForwardingManager fwManager, @Nonnull AclManager aclManager, - @Nonnull DataBroker dataProvider) { + @Nonnull DataBroker dataProvider) { this.fwManager = Preconditions.checkNotNull(fwManager); this.dataProvider = Preconditions.checkNotNull(dataProvider); this.aclManager = Preconditions.checkNotNull(aclManager); @@ -128,7 +128,7 @@ public class VppRendererPolicyManager { SetMultimap removedVppNodesByL2Fd = HashMultimap.create(); SetMultimap createdVppNodesByL2Fd = HashMultimap.create(); for (Entry>> entry : vppNodesByL2FlDiff.entriesDiffering() - .entrySet()) { + .entrySet()) { String bridgeDomain = entry.getKey(); Collection beforeNodes = entry.getValue().leftValue(); Collection afterNodes = entry.getValue().rightValue(); @@ -177,10 +177,10 @@ public class VppRendererPolicyManager { RendererForwarding rendererForwardingBefore = rPolicyBefore.getConfiguration().getRendererForwarding(); SetMultimap vppNodesByL2FdBefore = - resolveVppNodesByL2Fd(policyCtxBefore.getPolicyTable().rowKeySet(), policyCtxBefore); + resolveVppNodesByL2Fd(policyCtxBefore.getPolicyTable().rowKeySet(), policyCtxBefore); if (!vppNodesByL2FdBefore.isEmpty()) { LOG.debug("Deleting DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingBefore, - vppNodesByL2FdBefore); + vppNodesByL2FdBefore); fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore); } } @@ -188,10 +188,10 @@ public class VppRendererPolicyManager { if (rPolicyAfter.getConfiguration() != null) { RendererForwarding rendererForwardingAfter = rPolicyAfter.getConfiguration().getRendererForwarding(); SetMultimap vppNodesByL2FdAfter = - resolveVppNodesByL2Fd(policyCtxAfter.getPolicyTable().rowKeySet(), policyCtxAfter); + resolveVppNodesByL2Fd(policyCtxAfter.getPolicyTable().rowKeySet(), policyCtxAfter); if (!vppNodesByL2FdAfter.isEmpty()) { LOG.debug("Creating DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingAfter, - vppNodesByL2FdAfter); + vppNodesByL2FdAfter); fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter); } } @@ -248,27 +248,27 @@ public class VppRendererPolicyManager { continue; } policy.getPolicy() - .getConfiguration() - .getRendererEndpoints() - .getRendererEndpoint() - .stream() - .filter(rEp -> !updates.contains(rEp.getKey())) - .forEach(rEp -> { - for (PeerEndpoint pEp : rEp.getPeerEndpoint()) { - for (RuleGroupWithRendererEndpointParticipation rg : pEp - .getRuleGroupWithRendererEndpointParticipation()) { - if (!diffRuleGroups.contains( - new RuleGroupKey(rg.getContractId(), rg.getSubjectName(), rg.getTenantId()))) { - continue; - } - if (!policy.equals(policyCtxBefore)) { - updates.add(rEp.getKey()); - AddressEndpointKey k1 = AddressEndpointUtils.fromPeerEpKey(pEp.getKey()); - updates.add(AddressEndpointUtils.toRendererEpKey(k1)); + .getConfiguration() + .getRendererEndpoints() + .getRendererEndpoint() + .stream() + .filter(rEp -> !updates.contains(rEp.getKey())) + .forEach(rEp -> { + for (PeerEndpoint pEp : rEp.getPeerEndpoint()) { + for (RuleGroupWithRendererEndpointParticipation rg : pEp + .getRuleGroupWithRendererEndpointParticipation()) { + if (!diffRuleGroups.contains( + new RuleGroupKey(rg.getContractId(), rg.getSubjectName(), rg.getTenantId()))) { + continue; + } + if (!policy.equals(policyCtxBefore)) { + updates.add(rEp.getKey()); + AddressEndpointKey k1 = AddressEndpointUtils.fromPeerEpKey(pEp.getKey()); + updates.add(AddressEndpointUtils.toRendererEpKey(k1)); + } } } - } - }); + }); } for (RendererEndpointKey rEpKey : updates) { aclManager.updateAclsForRendEp(rEpKey, policyCtxAfter); @@ -288,7 +288,7 @@ public class VppRendererPolicyManager { } private static MapDifference> createDiffForVppNodesByL2Fd(PolicyContext policyCtxBefore, - PolicyContext policyCtxAfter) { + PolicyContext policyCtxAfter) { ImmutableSet rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet(); ImmutableSet rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet(); SetMultimap vppNodesByL2FdBefore = resolveVppNodesByL2Fd(rendEpsBefore, policyCtxBefore); @@ -333,23 +333,23 @@ public class VppRendererPolicyManager { } private static SetMultimap resolveVppNodesByL2Fd(Set rEpKeys, - PolicyContext policyCtx) { + PolicyContext policyCtx) { SetMultimap vppNodesByL2Fd = HashMultimap.create(); rEpKeys.stream() - .map(rEpKey -> KeyFactory.addressEndpointKey(rEpKey)) - .map(addrEpKey -> policyCtx.getAddrEpByKey().get(addrEpKey)) - .collect(Collectors.toSet()) - .forEach(addrEpWithLoc -> { - java.util.Optional optL2Fd = ForwardingManager.resolveL2FloodDomain(addrEpWithLoc, policyCtx); - if (optL2Fd.isPresent()) { - ExternalLocationCase rEpLoc = ForwardingManager.resolveAndValidateLocation(addrEpWithLoc); - if (rEpLoc != null) { - InstanceIdentifier externalNodeMountPoint = rEpLoc.getExternalNodeMountPoint(); - NodeId vppNode = externalNodeMountPoint.firstKeyOf(Node.class).getNodeId(); - vppNodesByL2Fd.put(optL2Fd.get(), vppNode); + .map(rEpKey -> KeyFactory.addressEndpointKey(rEpKey)) + .map(addrEpKey -> policyCtx.getAddrEpByKey().get(addrEpKey)) + .collect(Collectors.toSet()) + .forEach(addrEpWithLoc -> { + java.util.Optional optL2Fd = ForwardingManager.resolveL2FloodDomain(addrEpWithLoc, policyCtx); + if (optL2Fd.isPresent()) { + ExternalLocationCase rEpLoc = ForwardingManager.resolveAndValidateLocation(addrEpWithLoc); + if (rEpLoc != null) { + InstanceIdentifier externalNodeMountPoint = rEpLoc.getExternalNodeMountPoint(); + NodeId vppNode = externalNodeMountPoint.firstKeyOf(Node.class).getNodeId(); + vppNodesByL2Fd.put(optL2Fd.get(), vppNode); + } } - } - }); + }); return vppNodesByL2Fd; } diff --git a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java index d6d89e6a1..f2ac85ffb 100644 --- a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java +++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java @@ -129,7 +129,7 @@ public class VppRendererPolicyManagerTest extends CustomDataBrokerTest { bdManager = new BridgeDomainManagerImpl(mountPointDataBroker); lispStateManager = new LispStateManager(mountedDataProviderMock); loopbackManager = new LoopbackManager(mountedDataProviderMock); - flatOverlayManager = new FlatOverlayManager(mountedDataProviderMock); + flatOverlayManager = new FlatOverlayManager(dataBroker, mountedDataProviderMock); dhcpRelayHandler = new DhcpRelayHandler(dataBroker, mountedDataProviderMock); fwManager = new ForwardingManager(ifaceManager, aclManager, natManager, routingManager, bdManager, lispStateManager, loopbackManager, flatOverlayManager, dhcpRelayHandler, dataBroker); -- 2.36.6