X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=renderers%2Fvpp%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fgroupbasedpolicy%2Frenderer%2Fvpp%2Fpolicy%2FVppRendererPolicyManager.java;h=b380358c567d634563fb05025c6aaa2ae85eda5e;hb=521874598e3bea3866471f528416dde70e901183;hp=421073e747cb023c9c5ff60d28dcc0c00c155651;hpb=8188645803c08fc81a37982d586f8b8479688bc2;p=groupbasedpolicy.git 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..b380358c5 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 @@ -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,22 +23,19 @@ 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.util.AddressEndpointUtils; +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; import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AclManager; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey; 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.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding; 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.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpoint; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; @@ -54,9 +53,6 @@ import com.google.common.collect.SetMultimap; import com.google.common.collect.Sets; import com.google.common.collect.Sets.SetView; import com.google.common.eventbus.Subscribe; -import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; - public class VppRendererPolicyManager { @@ -66,7 +62,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); @@ -104,31 +100,24 @@ public class VppRendererPolicyManager { RendererPolicy response = responseBuilder.build(); wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.rendererIid(VppRenderer.NAME).child(RendererPolicy.class), response, true); - Futures.addCallback(wTx.submit(), new FutureCallback() { - - @Override - public void onSuccess(Void result) { - LOG.info("Renderer updated renderer policy to version {}", response.getVersion()); - } - - @Override - public void onFailure(Throwable t) { - LOG.warn("Renderer failed to update renderer-policy to version {}", response.getVersion()); - } - }); + try { + wTx.submit().get(); + } catch (Exception ex) { + LOG.trace("Got Exception in renderer policy update. Exception: {}", ex); + } } private void rendererPolicyUpdated(RendererPolicy rPolicyBefore, RendererPolicy rPolicyAfter) { LOG.trace("VPP renderer policy updated"); PolicyContext policyCtxBefore = new PolicyContext(rPolicyBefore); PolicyContext policyCtxAfter = new PolicyContext(rPolicyAfter); - aclManager.cacheMultiInterfaces(policyCtxAfter); + aclManager.cacheEndpointsByInterfaces(policyCtxAfter); MapDifference> vppNodesByL2FlDiff = createDiffForVppNodesByL2Fd(policyCtxBefore, policyCtxAfter); 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(); @@ -164,7 +153,6 @@ public class VppRendererPolicyManager { ImmutableSet rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet(); SetView removedRendEps = Sets.difference(rendEpsBefore, rendEpsAfter); - LOG.debug("Removed renderer endpoints {}", removedRendEps); removedRendEps.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore)); if (!ConfigUtil.getInstance().isL3FlatEnabled()) { @@ -173,28 +161,28 @@ public class VppRendererPolicyManager { LOG.debug("Creating bridge domains on nodes {}", createdVppNodesByL2Fd); fwManager.createBridgeDomainOnNodes(createdVppNodesByL2Fd); } else { + List deletedDhcpRelays = new ArrayList<>(); + List createdDhcpRelays = new ArrayList<>(); if (rPolicyBefore.getConfiguration() != null) { 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); - fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore); + deletedDhcpRelays = fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore); } } 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); - fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter); + createdDhcpRelays = fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter); } } + + fwManager.syncDhcpRelay(createdDhcpRelays, deletedDhcpRelays); } fwManager.syncNatEntries(policyCtxAfter); @@ -203,11 +191,9 @@ public class VppRendererPolicyManager { fwManager.syncRouting(policyCtxAfter); SetView createdRendEps = Sets.difference(rendEpsAfter, rendEpsBefore); - LOG.debug("Created renderer endpoints {}", createdRendEps); createdRendEps.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter)); SetView updatedRendEps = Sets.intersection(rendEpsBefore, rendEpsAfter); - LOG.debug("Updated renderer endpoints {}", updatedRendEps); // update forwarding for endpoint updatedRendEps.forEach(rEpKey -> { AddressEndpointWithLocation addrEpWithLocBefore = @@ -222,73 +208,34 @@ public class VppRendererPolicyManager { fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter); } }); - updatePolicy(policyCtxBefore, policyCtxAfter); - } - - /** - * Looks for changed rule groups in {@code policyCtxBefore} and {@code policyCtxAfter}. - * Access lists are updated for endpoints in {@code policyCtxAfter} affected by changed rule - * groups. - * - * @param policyCtxBefore policy before - * @param policyCtxAfter policy after - */ - private void updatePolicy(PolicyContext policyCtxBefore, PolicyContext policyCtxAfter) { - LOG.info("Updating policy by rule groups."); - Set diffRuleGroups = new HashSet<>(); - diffRuleGroups.addAll(Sets.difference(policyCtxBefore.getRuleGroupByKey().keySet(), - policyCtxAfter.getRuleGroupByKey().keySet())); - diffRuleGroups.addAll(Sets.difference(policyCtxAfter.getRuleGroupByKey().keySet(), policyCtxBefore.getRuleGroupByKey().keySet())); - LOG.trace("Rule groups changed: {} ", diffRuleGroups.size()); - Set updates = new HashSet<>(); - for (PolicyContext policy : new PolicyContext[] {policyCtxBefore, policyCtxAfter}) { - if (policy.getPolicy().getConfiguration() == null - || policy.getPolicy().getConfiguration().getRendererEndpoints() == null - || policy.getPolicy().getConfiguration().getRendererEndpoints().getRendererEndpoint() == null) { - 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)); - } - } - } - }); - } - for (RendererEndpointKey rEpKey : updates) { - aclManager.updateAclsForRendEp(rEpKey, policyCtxAfter); - } + ImmutableSet rulesBefore = policyCtxAfter.getRuleGroupByKey().keySet(); + ImmutableSet rulesAfter = policyCtxBefore.getRuleGroupByKey().keySet(); + SetView removedRules = Sets.difference(rulesAfter, rulesBefore); + SetView 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); } 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); } 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); @@ -299,25 +246,26 @@ 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 rEpKeys = policyCtx.getPolicyTable().rowKeySet(); SetMultimap vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx); if (!ConfigUtil.getInstance().isL3FlatEnabled()) { fwManager.createBridgeDomainOnNodes(vppNodesByL2Fd); } else { RendererForwarding rendererForwarding = rPolicy.getConfiguration().getRendererForwarding(); - fwManager.createDhcpRelay(rendererForwarding, vppNodesByL2Fd); + List createdDhcpRelays = fwManager.createDhcpRelay(rendererForwarding, vppNodesByL2Fd); + fwManager.syncDhcpRelay(createdDhcpRelays, new ArrayList<>()); } + rEpKeys.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtx)); fwManager.syncNatEntries(policyCtx); fwManager.syncRouting(policyCtx); - rEpKeys.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtx)); } 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 rEpKeys = policyCtx.getPolicyTable().rowKeySet(); rEpKeys.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtx)); @@ -326,30 +274,31 @@ public class VppRendererPolicyManager { fwManager.removeBridgeDomainOnNodes(vppNodesByL2Fd); } else { RendererForwarding rendererForwarding = rendererPolicy.getConfiguration().getRendererForwarding(); - fwManager.deleteDhcpRelay(rendererForwarding, vppNodesByL2Fd); + List deletedDhcpRelays = fwManager.deleteDhcpRelay(rendererForwarding, vppNodesByL2Fd); + fwManager.syncDhcpRelay(new ArrayList<>(), deletedDhcpRelays); } fwManager.deleteNatEntries(policyCtx); fwManager.deleteRouting(policyCtx); } 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; }