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