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

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
  10
  11 import java.util.Collection;
  12 import java.util.HashSet;
  13 import java.util.Map;
  14 import java.util.Map.Entry;
  15 import java.util.Set;
  16 import java.util.stream.Collectors;
  17
  18 import javax.annotation.Nonnull;
  19
  20 import org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppRenderer;
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.config.ConfigUtil;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.NodeOperEvent;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.RendererPolicyConfEvent;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AclManager;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
  29 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupKey;
  37 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  38 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 import com.google.common.base.Preconditions;
  44 import com.google.common.collect.HashMultimap;
  45 import com.google.common.collect.ImmutableSet;
  46 import com.google.common.collect.MapDifference;
  47 import com.google.common.collect.MapDifference.ValueDifference;
  48 import com.google.common.collect.Maps;
  49 import com.google.common.collect.SetMultimap;
  50 import com.google.common.collect.Sets;
  51 import com.google.common.collect.Sets.SetView;
  52 import com.google.common.eventbus.Subscribe;
  53
  54 public class VppRendererPolicyManager {
  55
  56     private static final Logger LOG = LoggerFactory.getLogger(VppRendererPolicyManager.class);
  57     private final DataBroker dataProvider;
  58     private ForwardingManager fwManager;
  59     private final AclManager aclManager;
  60
  61     public VppRendererPolicyManager(@Nonnull ForwardingManager fwManager, @Nonnull AclManager aclManager,
  62                                     @Nonnull DataBroker dataProvider) {
  63         this.fwManager = Preconditions.checkNotNull(fwManager);
  64         this.dataProvider = Preconditions.checkNotNull(dataProvider);
  65         this.aclManager = Preconditions.checkNotNull(aclManager);
  66     }
  67
  68     @Subscribe
  69     public void rendererPolicyChanged(RendererPolicyConfEvent event) {
  70         RendererPolicyBuilder responseBuilder = new RendererPolicyBuilder();
  71         switch (event.getDtoModificationType()) {
  72             case CREATED:
  73                 LOG.debug("CREATED : {}", event.getIid());
  74                 responseBuilder.setVersion(event.getAfter().get().getVersion());
  75                 rendererPolicyCreated(event.getAfter().get());
  76                 break;
  77             case UPDATED:
  78                 LOG.debug("UPDATED: {}", event.getIid());
  79                 RendererPolicy rPolicyBefore = event.getBefore().get();
  80                 RendererPolicy rPolicyAfter = event.getAfter().get();
  81                 responseBuilder.setVersion(rPolicyAfter.getVersion());
  82                 if (rPolicyBefore.getConfiguration() == null && rPolicyAfter.getConfiguration() == null) {
  83                     LOG.debug("Configuration is not changed only updating config version from {} to {}",
  84                             rPolicyBefore.getVersion(), rPolicyAfter.getVersion());
  85                 } else {
  86                     // TODO collect unconfigured rules and put them to responseBuilder
  87                     rendererPolicyUpdated(rPolicyBefore, rPolicyAfter);
  88                 }
  89                 break;
  90             case DELETED:
  91                 LOG.debug("DELETED: {}", event.getIid());
  92                 responseBuilder.setVersion(event.getBefore().get().getVersion());
  93                 rendererPolicyDeleted(event.getBefore().get());
  94                 break;
  95         }
  96         WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
  97         RendererPolicy response = responseBuilder.build();
  98         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.rendererIid(VppRenderer.NAME).child(RendererPolicy.class),
  99                 response, true);
 100         try {
 101             wTx.submit().get();
 102         } catch (Exception ex) {
 103             LOG.trace("Got Exception in renderer policy update. Exception: {}", ex);
 104         }
 105     }
 106
 107     private void rendererPolicyUpdated(RendererPolicy rPolicyBefore, RendererPolicy rPolicyAfter) {
 108         LOG.trace("VPP renderer policy updated");
 109         PolicyContext policyCtxBefore = new PolicyContext(rPolicyBefore);
 110         PolicyContext policyCtxAfter = new PolicyContext(rPolicyAfter);
 111         aclManager.cacheMultiInterfaces(policyCtxAfter);
 112         MapDifference<String, Collection<NodeId>> vppNodesByL2FlDiff =
 113                 createDiffForVppNodesByL2Fd(policyCtxBefore, policyCtxAfter);
 114         SetMultimap<String, NodeId> removedVppNodesByL2Fd = HashMultimap.create();
 115         SetMultimap<String, NodeId> createdVppNodesByL2Fd = HashMultimap.create();
 116         for (Entry<String, ValueDifference<Collection<NodeId>>> entry : vppNodesByL2FlDiff.entriesDiffering()
 117                 .entrySet()) {
 118             String bridgeDomain = entry.getKey();
 119             Collection<NodeId> beforeNodes = entry.getValue().leftValue();
 120             Collection<NodeId> afterNodes = entry.getValue().rightValue();
 121             if (beforeNodes != null && afterNodes != null) {
 122                 SetView<NodeId> removedNodes = Sets.difference(new HashSet<>(beforeNodes), new HashSet<>(afterNodes));
 123                 removedVppNodesByL2Fd.putAll(bridgeDomain, removedNodes);
 124                 SetView<NodeId> createdNodes = Sets.difference(new HashSet<>(afterNodes), new HashSet<>(beforeNodes));
 125                 createdVppNodesByL2Fd.putAll(bridgeDomain, createdNodes);
 126             } else if (beforeNodes != null) {
 127                 removedVppNodesByL2Fd.putAll(bridgeDomain, beforeNodes);
 128             } else if (afterNodes != null) {
 129                 createdVppNodesByL2Fd.putAll(bridgeDomain, afterNodes);
 130             }
 131         }
 132         Map<String, Collection<NodeId>> removedL2Fds = vppNodesByL2FlDiff.entriesOnlyOnLeft();
 133         for (Entry<String, Collection<NodeId>> entry : removedL2Fds.entrySet()) {
 134             String bridgeDomain = entry.getKey();
 135             Collection<NodeId> removedNodes = entry.getValue();
 136             if (removedNodes != null) {
 137                 removedVppNodesByL2Fd.putAll(bridgeDomain, removedNodes);
 138             }
 139         }
 140         Map<String, Collection<NodeId>> createdL2Fds = vppNodesByL2FlDiff.entriesOnlyOnRight();
 141         for (Entry<String, Collection<NodeId>> entry : createdL2Fds.entrySet()) {
 142             String bridgeDomain = entry.getKey();
 143             Collection<NodeId> createdNodes = entry.getValue();
 144             if (createdNodes != null) {
 145                 createdVppNodesByL2Fd.putAll(bridgeDomain, createdNodes);
 146             }
 147         }
 148
 149         ImmutableSet<RendererEndpointKey> rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet();
 150         ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
 151
 152         SetView<RendererEndpointKey> removedRendEps = Sets.difference(rendEpsBefore, rendEpsAfter);
 153         LOG.debug("Removed renderer endpoints {}", removedRendEps);
 154         removedRendEps.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore));
 155
 156         if (!ConfigUtil.getInstance().isL3FlatEnabled()) {
 157             LOG.debug("Removing bridge domains on nodes {}", removedVppNodesByL2Fd);
 158             fwManager.removeBridgeDomainOnNodes(removedVppNodesByL2Fd);
 159             LOG.debug("Creating bridge domains on nodes {}", createdVppNodesByL2Fd);
 160             fwManager.createBridgeDomainOnNodes(createdVppNodesByL2Fd);
 161         } else {
 162             if (rPolicyBefore.getConfiguration() != null) {
 163                 RendererForwarding rendererForwardingBefore = rPolicyBefore.getConfiguration().getRendererForwarding();
 164
 165                 SetMultimap<String, NodeId> vppNodesByL2FdBefore =
 166                         resolveVppNodesByL2Fd(policyCtxBefore.getPolicyTable().rowKeySet(), policyCtxBefore);
 167                 if (!vppNodesByL2FdBefore.isEmpty()) {
 168                     LOG.debug("Deleting DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingBefore,
 169                             vppNodesByL2FdBefore);
 170                     fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore);
 171                 }
 172             }
 173
 174             if (rPolicyAfter.getConfiguration() != null) {
 175                 RendererForwarding rendererForwardingAfter = rPolicyAfter.getConfiguration().getRendererForwarding();
 176                 SetMultimap<String, NodeId> vppNodesByL2FdAfter =
 177                         resolveVppNodesByL2Fd(policyCtxAfter.getPolicyTable().rowKeySet(), policyCtxAfter);
 178                 if (!vppNodesByL2FdAfter.isEmpty()) {
 179                     LOG.debug("Creating DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingAfter,
 180                             vppNodesByL2FdAfter);
 181                     fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter);
 182                 }
 183             }
 184         }
 185
 186         fwManager.syncNatEntries(policyCtxAfter);
 187
 188         fwManager.deleteRouting(policyCtxBefore);
 189         fwManager.syncRouting(policyCtxAfter);
 190
 191         SetView<RendererEndpointKey> createdRendEps = Sets.difference(rendEpsAfter, rendEpsBefore);
 192         LOG.debug("Created renderer endpoints {}", createdRendEps);
 193         createdRendEps.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter));
 194
 195         SetView<RendererEndpointKey> updatedRendEps = Sets.intersection(rendEpsBefore, rendEpsAfter);
 196         LOG.debug("Updated renderer endpoints {}", updatedRendEps);
 197         // update forwarding for endpoint
 198         updatedRendEps.forEach(rEpKey -> {
 199             AddressEndpointWithLocation addrEpWithLocBefore =
 200                     policyCtxBefore.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
 201             AddressEndpointWithLocation addrEpWithLocAfter =
 202                     policyCtxAfter.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
 203             if (isLocationChanged(addrEpWithLocBefore, addrEpWithLocAfter)) {
 204                 LOG.debug("Location is changed in endpoint {}", rEpKey);
 205                 LOG.debug("\nLocation before: {}\nLocation after: {}", addrEpWithLocBefore.getAbsoluteLocation(),
 206                         addrEpWithLocAfter.getAbsoluteLocation());
 207                 fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore);
 208                 fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter);
 209             }
 210         });
 211         ImmutableSet<RuleGroupKey> rulesBefore = policyCtxAfter.getRuleGroupByKey().keySet();
 212         ImmutableSet<RuleGroupKey> rulesAfter = policyCtxBefore.getRuleGroupByKey().keySet();
 213         SetView<RuleGroupKey> removedRules = Sets.difference(rulesAfter, rulesBefore);
 214         SetView<RuleGroupKey> createdRules = Sets.difference(rulesBefore, rulesAfter);
 215         LOG.debug("Removed rules {}", removedRules);
 216         LOG.debug("Created rules {}", createdRules);
 217         aclManager.resolveRulesToConfigure(policyCtxBefore, removedRendEps, removedRules, false);
 218         aclManager.resolveRulesToConfigure(policyCtxAfter, createdRendEps, createdRules, true);
 219     }
 220
 221     private static boolean isLocationChanged(AddressEndpointWithLocation before, AddressEndpointWithLocation after) {
 222         ExternalLocationCase locationBefore = ForwardingManager.resolveAndValidateLocation(before);
 223         ExternalLocationCase locationAfter = ForwardingManager.resolveAndValidateLocation(after);
 224         if(locationBefore == null && locationAfter == null) {
 225             return false;
 226         }
 227         if(locationBefore == null || locationAfter == null) {
 228             return true;
 229         }
 230         return !locationBefore.equals(locationAfter);
 231     }
 232
 233     private static MapDifference<String, Collection<NodeId>> createDiffForVppNodesByL2Fd(PolicyContext policyCtxBefore,
 234                                                                                          PolicyContext policyCtxAfter) {
 235         ImmutableSet<RendererEndpointKey> rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet();
 236         ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
 237         SetMultimap<String, NodeId> vppNodesByL2FdBefore = resolveVppNodesByL2Fd(rendEpsBefore, policyCtxBefore);
 238         SetMultimap<String, NodeId> vppNodesByL2FdAfter = resolveVppNodesByL2Fd(rendEpsAfter, policyCtxAfter);
 239         return Maps.difference(vppNodesByL2FdBefore.asMap(), vppNodesByL2FdAfter.asMap());
 240     }
 241
 242     private void rendererPolicyCreated(RendererPolicy rPolicy) {
 243         LOG.trace("VPP renderer policy version {} created", rPolicy.getVersion());
 244         PolicyContext policyCtx = new PolicyContext(rPolicy);
 245         aclManager.cacheMultiInterfaces(policyCtx);
 246         ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
 247         SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
 248         if (!ConfigUtil.getInstance().isL3FlatEnabled()) {
 249             fwManager.createBridgeDomainOnNodes(vppNodesByL2Fd);
 250         } else {
 251             RendererForwarding rendererForwarding = rPolicy.getConfiguration().getRendererForwarding();
 252             fwManager.createDhcpRelay(rendererForwarding, vppNodesByL2Fd);
 253         }
 254
 255         rEpKeys.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtx));
 256         fwManager.syncNatEntries(policyCtx);
 257         fwManager.syncRouting(policyCtx);
 258     }
 259
 260     private void rendererPolicyDeleted(RendererPolicy rendererPolicy) {
 261         LOG.trace("VPP renderer policy version {} deleted", rendererPolicy.getVersion());
 262         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
 263         aclManager.cacheMultiInterfaces(policyCtx);
 264         ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
 265
 266         rEpKeys.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtx));
 267         SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
 268         if (!ConfigUtil.getInstance().isL3FlatEnabled()) {
 269             fwManager.removeBridgeDomainOnNodes(vppNodesByL2Fd);
 270         } else {
 271             RendererForwarding rendererForwarding = rendererPolicy.getConfiguration().getRendererForwarding();
 272             fwManager.deleteDhcpRelay(rendererForwarding, vppNodesByL2Fd);
 273         }
 274         fwManager.deleteNatEntries(policyCtx);
 275         fwManager.deleteRouting(policyCtx);
 276     }
 277
 278     private static SetMultimap<String, NodeId> resolveVppNodesByL2Fd(Set<RendererEndpointKey> rEpKeys,
 279                                                                      PolicyContext policyCtx) {
 280         SetMultimap<String, NodeId> vppNodesByL2Fd = HashMultimap.create();
 281         rEpKeys.stream()
 282                 .map(rEpKey -> KeyFactory.addressEndpointKey(rEpKey))
 283                 .map(addrEpKey -> policyCtx.getAddrEpByKey().get(addrEpKey))
 284                 .collect(Collectors.toSet())
 285                 .forEach(addrEpWithLoc -> {
 286                     java.util.Optional<String> optL2Fd = ForwardingManager.resolveL2FloodDomain(addrEpWithLoc, policyCtx);
 287                     if (optL2Fd.isPresent()) {
 288                         ExternalLocationCase rEpLoc = ForwardingManager.resolveAndValidateLocation(addrEpWithLoc);
 289                         if (rEpLoc != null) {
 290                             InstanceIdentifier<?> externalNodeMountPoint = rEpLoc.getExternalNodeMountPoint();
 291                             NodeId vppNode = externalNodeMountPoint.firstKeyOf(Node.class).getNodeId();
 292                             vppNodesByL2Fd.put(optL2Fd.get(), vppNode);
 293                         }
 294                     }
 295                 });
 296         return vppNodesByL2Fd;
 297     }
 298
 299     @Subscribe
 300     public void vppNodeChanged(NodeOperEvent event) {
 301         switch (event.getDtoModificationType()) {
 302             case CREATED:
 303                 if (event.isAfterConnected()) {
 304                     // TODO
 305                 }
 306                 break;
 307             case UPDATED:
 308                 if (!event.isBeforeConnected() && event.isAfterConnected()) {
 309                     // TODO
 310                 }
 311                 break;
 312             case DELETED:
 313                 if (event.isBeforeConnected()) {
 314                     // TODO
 315                 }
 316                 break;
 317         }
 318     }
 319 }