Optimize DHCP relay processing for VPP

[groupbasedpolicy.git] / renderers / vpp / src / main / java / org / opendaylight / groupbasedpolicy / renderer / vpp / policy / VppRendererPolicyManager.java

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 7fa28fe02cab996bf2c10f6e4c98d94b50512a52..b380358c567d634563fb05025c6aaa2ae85eda5e 100644 (file)
--- 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
@@ -8,8 +8,10 @@
 
 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
@@ -21,6 +23,7 @@ import org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppRende
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.DhcpRelayCommand;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.config.ConfigUtil;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.NodeOperEvent;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.RendererPolicyConfEvent;
@@ -108,7 +111,7 @@ public class VppRendererPolicyManager {
         LOG.trace("VPP renderer policy updated");
         PolicyContext policyCtxBefore = new PolicyContext(rPolicyBefore);
         PolicyContext policyCtxAfter = new PolicyContext(rPolicyAfter);
-        aclManager.cacheMultiInterfaces(policyCtxAfter);
+        aclManager.cacheEndpointsByInterfaces(policyCtxAfter);
         MapDifference<String, Collection<NodeId>> vppNodesByL2FlDiff =
                 createDiffForVppNodesByL2Fd(policyCtxBefore, policyCtxAfter);
         SetMultimap<String, NodeId> removedVppNodesByL2Fd = HashMultimap.create();
@@ -150,7 +153,6 @@ public class VppRendererPolicyManager {
         ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
 
         SetView<RendererEndpointKey> removedRendEps = Sets.difference(rendEpsBefore, rendEpsAfter);
-        LOG.debug("Removed renderer endpoints {}", removedRendEps);
         removedRendEps.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore));
 
         if (!ConfigUtil.getInstance().isL3FlatEnabled()) {
@@ -159,15 +161,15 @@ public class VppRendererPolicyManager {
             LOG.debug("Creating bridge domains on nodes {}", createdVppNodesByL2Fd);
             fwManager.createBridgeDomainOnNodes(createdVppNodesByL2Fd);
         } else {
+            List<DhcpRelayCommand> deletedDhcpRelays = new ArrayList<>();
+            List<DhcpRelayCommand> createdDhcpRelays = new ArrayList<>();
             if (rPolicyBefore.getConfiguration() != null) {
                 RendererForwarding rendererForwardingBefore = rPolicyBefore.getConfiguration().getRendererForwarding();
 
                 SetMultimap<String, NodeId> vppNodesByL2FdBefore =
                         resolveVppNodesByL2Fd(policyCtxBefore.getPolicyTable().rowKeySet(), policyCtxBefore);
                 if (!vppNodesByL2FdBefore.isEmpty()) {
-                    LOG.debug("Deleting DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingBefore,
-                            vppNodesByL2FdBefore);
-                    fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore);
+                    deletedDhcpRelays = fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore);
                 }
             }
 
@@ -176,11 +178,11 @@ public class VppRendererPolicyManager {
                 SetMultimap<String, NodeId> vppNodesByL2FdAfter =
                         resolveVppNodesByL2Fd(policyCtxAfter.getPolicyTable().rowKeySet(), policyCtxAfter);
                 if (!vppNodesByL2FdAfter.isEmpty()) {
-                    LOG.debug("Creating DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingAfter,
-                            vppNodesByL2FdAfter);
-                    fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter);
+                    createdDhcpRelays = fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter);
                 }
             }
+
+            fwManager.syncDhcpRelay(createdDhcpRelays, deletedDhcpRelays);
         }
 
         fwManager.syncNatEntries(policyCtxAfter);
@@ -189,11 +191,9 @@ public class VppRendererPolicyManager {
         fwManager.syncRouting(policyCtxAfter);
 
         SetView<RendererEndpointKey> createdRendEps = Sets.difference(rendEpsAfter, rendEpsBefore);
-        LOG.debug("Created renderer endpoints {}", createdRendEps);
         createdRendEps.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter));
 
         SetView<RendererEndpointKey> updatedRendEps = Sets.intersection(rendEpsBefore, rendEpsAfter);
-        LOG.debug("Updated renderer endpoints {}", updatedRendEps);
         // update forwarding for endpoint
         updatedRendEps.forEach(rEpKey -> {
             AddressEndpointWithLocation addrEpWithLocBefore =
@@ -212,8 +212,12 @@ public class VppRendererPolicyManager {
         ImmutableSet<RuleGroupKey> rulesAfter = policyCtxBefore.getRuleGroupByKey().keySet();
         SetView<RuleGroupKey> removedRules = Sets.difference(rulesAfter, rulesBefore);
         SetView<RuleGroupKey> createdRules = Sets.difference(rulesBefore, rulesAfter);
+        LOG.debug("Updated rules: {}", Sets.intersection(rulesBefore, rulesAfter));
         LOG.debug("Removed rules {}", removedRules);
         LOG.debug("Created rules {}", createdRules);
+        LOG.debug("Updated renderer endpoints {}", updatedRendEps);
+        LOG.debug("Created renderer endpoints {}", createdRendEps);
+        LOG.debug("Updated renderer endpoints {}", updatedRendEps);
         aclManager.resolveRulesToConfigure(policyCtxBefore, removedRendEps, removedRules, false);
         aclManager.resolveRulesToConfigure(policyCtxAfter, createdRendEps, createdRules, true);
     }
@@ -221,10 +225,10 @@ public class VppRendererPolicyManager {
     private static boolean isLocationChanged(AddressEndpointWithLocation before, AddressEndpointWithLocation after) {
         ExternalLocationCase locationBefore = ForwardingManager.resolveAndValidateLocation(before);
         ExternalLocationCase locationAfter = ForwardingManager.resolveAndValidateLocation(after);
-        if(locationBefore == null && locationAfter == null) {
+        if (locationBefore == null && locationAfter == null) {
             return false;
         }
-        if(locationBefore == null || locationAfter == null) {
+        if (locationBefore == null || locationAfter == null) {
             return true;
         }
         return !locationBefore.equals(locationAfter);
@@ -242,14 +246,15 @@ public class VppRendererPolicyManager {
     private void rendererPolicyCreated(RendererPolicy rPolicy) {
         LOG.trace("VPP renderer policy version {} created", rPolicy.getVersion());
         PolicyContext policyCtx = new PolicyContext(rPolicy);
-        aclManager.cacheMultiInterfaces(policyCtx);
+        aclManager.cacheEndpointsByInterfaces(policyCtx);
         ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
         SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
         if (!ConfigUtil.getInstance().isL3FlatEnabled()) {
             fwManager.createBridgeDomainOnNodes(vppNodesByL2Fd);
         } else {
             RendererForwarding rendererForwarding = rPolicy.getConfiguration().getRendererForwarding();
-            fwManager.createDhcpRelay(rendererForwarding, vppNodesByL2Fd);
+            List<DhcpRelayCommand> createdDhcpRelays = fwManager.createDhcpRelay(rendererForwarding, vppNodesByL2Fd);
+            fwManager.syncDhcpRelay(createdDhcpRelays, new ArrayList<>());
         }
 
         rEpKeys.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtx));
@@ -260,7 +265,7 @@ public class VppRendererPolicyManager {
     private void rendererPolicyDeleted(RendererPolicy rendererPolicy) {
         LOG.trace("VPP renderer policy version {} deleted", rendererPolicy.getVersion());
         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
-        aclManager.cacheMultiInterfaces(policyCtx);
+        aclManager.cacheEndpointsByInterfaces(policyCtx);
         ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
 
         rEpKeys.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtx));
@@ -269,7 +274,8 @@ public class VppRendererPolicyManager {
             fwManager.removeBridgeDomainOnNodes(vppNodesByL2Fd);
         } else {
             RendererForwarding rendererForwarding = rendererPolicy.getConfiguration().getRendererForwarding();
-            fwManager.deleteDhcpRelay(rendererForwarding, vppNodesByL2Fd);
+            List<DhcpRelayCommand> deletedDhcpRelays = fwManager.deleteDhcpRelay(rendererForwarding, vppNodesByL2Fd);
+            fwManager.syncDhcpRelay(new ArrayList<>(), deletedDhcpRelays);
         }
         fwManager.deleteNatEntries(policyCtx);
         fwManager.deleteRouting(policyCtx);