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.event.NodeOperEvent;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.RendererPolicyConfEvent;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
  27 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
  33 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  34 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 import com.google.common.base.Optional;
  40 import com.google.common.base.Preconditions;
  41 import com.google.common.collect.HashMultimap;
  42 import com.google.common.collect.ImmutableSet;
  43 import com.google.common.collect.MapDifference;
  44 import com.google.common.collect.MapDifference.ValueDifference;
  45 import com.google.common.collect.Maps;
  46 import com.google.common.collect.SetMultimap;
  47 import com.google.common.collect.Sets;
  48 import com.google.common.collect.Sets.SetView;
  49 import com.google.common.eventbus.Subscribe;
  50 import com.google.common.util.concurrent.FutureCallback;
  51 import com.google.common.util.concurrent.Futures;
  52
  53 public class VppRendererPolicyManager {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(VppRendererPolicyManager.class);
  56     private final DataBroker dataProvider;
  57     private ForwardingManager fwManager;
  58
  59     public VppRendererPolicyManager(@Nonnull ForwardingManager fwManager, @Nonnull DataBroker dataProvider) {
  60         this.fwManager = Preconditions.checkNotNull(fwManager);
  61         this.dataProvider = Preconditions.checkNotNull(dataProvider);
  62     }
  63
  64     @Subscribe
  65     public void rendererPolicyChanged(RendererPolicyConfEvent event) {
  66         RendererPolicyBuilder responseBuilder = new RendererPolicyBuilder();
  67         switch (event.getDtoModificationType()) {
  68             case CREATED:
  69                 LOG.trace("CREATED : {}", event.getIid());
  70                 responseBuilder.setVersion(event.getAfter().get().getVersion());
  71                 rendererPolicyCreated(event.getAfter().get());
  72                 break;
  73             case UPDATED:
  74                 LOG.trace("UPDATED: {}", event.getIid());
  75                 RendererPolicy rPolicyBefore = event.getBefore().get();
  76                 RendererPolicy rPolicyAfter = event.getAfter().get();
  77                 responseBuilder.setVersion(rPolicyAfter.getVersion());
  78                 if (rPolicyBefore.getConfiguration() == null && rPolicyAfter.getConfiguration() == null) {
  79                     LOG.debug("Configuration is not changed only updating config version from {} to {}",
  80                             rPolicyBefore.getVersion(), rPolicyAfter.getVersion());
  81                 } else {
  82                     // TODO collect unconfigured rules and put them to responseBuilder
  83                     rendererPolicyUpdated(rPolicyBefore, rPolicyAfter);
  84                 }
  85                 break;
  86             case DELETED:
  87                 LOG.trace("DELETED: {}", event.getIid());
  88                 responseBuilder.setVersion(event.getBefore().get().getVersion());
  89                 rendererPolicyDeleted(event.getBefore().get());
  90                 break;
  91         }
  92         WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
  93         RendererPolicy response = responseBuilder.build();
  94         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.rendererIid(VppRenderer.NAME).child(RendererPolicy.class),
  95                 response, true);
  96         Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
  97
  98             @Override
  99             public void onSuccess(Void result) {
 100                 LOG.debug("Renderer updated renderer policy {}", response);
 101             }
 102
 103             @Override
 104             public void onFailure(Throwable t) {
 105                 LOG.warn("Renderer DIDN'T update renderer-policy {}", response);
 106             }
 107         });
 108     }
 109
 110     private void rendererPolicyUpdated(RendererPolicy rPolicyBefore, RendererPolicy rPolicyAfter) {
 111         PolicyContext policyCtxBefore = new PolicyContext(rPolicyBefore);
 112         PolicyContext policyCtxAfter = new PolicyContext(rPolicyAfter);
 113
 114         MapDifference<String, Collection<NodeId>> vppNodesByL2FlDiff =
 115                 createDiffForVppNodesByL2Fd(policyCtxBefore, policyCtxAfter);
 116         SetMultimap<String, NodeId> removedVppNodesByL2Fd = HashMultimap.create();
 117         SetMultimap<String, NodeId> createdVppNodesByL2Fd = HashMultimap.create();
 118         for (Entry<String, ValueDifference<Collection<NodeId>>> entry : vppNodesByL2FlDiff.entriesDiffering()
 119             .entrySet()) {
 120             String bridgeDomain = entry.getKey();
 121             Collection<NodeId> beforeNodes = entry.getValue().leftValue();
 122             Collection<NodeId> afterNodes = entry.getValue().rightValue();
 123             if (beforeNodes != null && afterNodes != null) {
 124                 SetView<NodeId> removedNodes = Sets.difference(new HashSet<>(beforeNodes), new HashSet<>(afterNodes));
 125                 removedVppNodesByL2Fd.putAll(bridgeDomain, removedNodes);
 126                 SetView<NodeId> createdNodes = Sets.difference(new HashSet<>(afterNodes), new HashSet<>(beforeNodes));
 127                 createdVppNodesByL2Fd.putAll(bridgeDomain, createdNodes);
 128             } else if (beforeNodes != null) {
 129                 removedVppNodesByL2Fd.putAll(bridgeDomain, beforeNodes);
 130             } else if (afterNodes != null) {
 131                 createdVppNodesByL2Fd.putAll(bridgeDomain, afterNodes);
 132             }
 133         }
 134         Map<String, Collection<NodeId>> removedL2Fds = vppNodesByL2FlDiff.entriesOnlyOnLeft();
 135         for (Entry<String, Collection<NodeId>> entry : removedL2Fds.entrySet()) {
 136             String bridgeDomain = entry.getKey();
 137             Collection<NodeId> removedNodes = entry.getValue();
 138             if (removedNodes != null) {
 139                 removedVppNodesByL2Fd.putAll(bridgeDomain, removedNodes);
 140             }
 141         }
 142         Map<String, Collection<NodeId>> createdL2Fds = vppNodesByL2FlDiff.entriesOnlyOnRight();
 143         for (Entry<String, Collection<NodeId>> entry : createdL2Fds.entrySet()) {
 144             String bridgeDomain = entry.getKey();
 145             Collection<NodeId> createdNodes = entry.getValue();
 146             if (createdNodes != null) {
 147                 createdVppNodesByL2Fd.putAll(bridgeDomain, createdNodes);
 148             }
 149         }
 150
 151         ImmutableSet<RendererEndpointKey> rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet();
 152         ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
 153
 154         SetView<RendererEndpointKey> removedRendEps = Sets.difference(rendEpsBefore, rendEpsAfter);
 155         LOG.trace("Removed renderer endpoints {}", removedRendEps);
 156         removedRendEps.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore));
 157
 158         LOG.trace("Removed bridge domains on nodes {}", removedVppNodesByL2Fd);
 159         LOG.trace("Created bridge domains on nodes {}", createdVppNodesByL2Fd);
 160         fwManager.removeBridgeDomainOnNodes(removedVppNodesByL2Fd);
 161         fwManager.createBridgeDomainOnNodes(createdVppNodesByL2Fd);
 162
 163         SetView<RendererEndpointKey> createdRendEps = Sets.difference(rendEpsAfter, rendEpsBefore);
 164         LOG.trace("Created renderer endpoints {}", createdRendEps);
 165         createdRendEps.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter));
 166
 167         SetView<RendererEndpointKey> updatedRendEps = Sets.intersection(rendEpsBefore, rendEpsAfter);
 168         LOG.trace("Updated renderer endpoints {}", updatedRendEps);
 169         // update forwarding for endpoint
 170         updatedRendEps.forEach(rEpKey -> {
 171             AddressEndpointWithLocation addrEpWithLocBefore =
 172                     policyCtxBefore.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
 173             AddressEndpointWithLocation addrEpWithLocAfter =
 174                     policyCtxAfter.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
 175             if (isLocationChanged(addrEpWithLocBefore, addrEpWithLocAfter)) {
 176                 LOG.debug("Location is changed in endpoint {}", rEpKey);
 177                 LOG.trace("\nLocation before: {}\nLocation after: {}", addrEpWithLocBefore.getAbsoluteLocation(),
 178                         addrEpWithLocAfter.getAbsoluteLocation());
 179                 fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore);
 180                 fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter);
 181             }
 182         });
 183     }
 184
 185     private static boolean isLocationChanged(AddressEndpointWithLocation before, AddressEndpointWithLocation after) {
 186         ExternalLocationCase locationBefore = ForwardingManager.resolveAndValidateLocation(before);
 187         ExternalLocationCase locationAfter = ForwardingManager.resolveAndValidateLocation(after);
 188         return !locationBefore.equals(locationAfter);
 189     }
 190
 191     private static MapDifference<String, Collection<NodeId>> createDiffForVppNodesByL2Fd(PolicyContext policyCtxBefore,
 192             PolicyContext policyCtxAfter) {
 193         ImmutableSet<RendererEndpointKey> rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet();
 194         ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
 195         SetMultimap<String, NodeId> vppNodesByL2FdBefore = resolveVppNodesByL2Fd(rendEpsBefore, policyCtxBefore);
 196         SetMultimap<String, NodeId> vppNodesByL2FdAfter = resolveVppNodesByL2Fd(rendEpsAfter, policyCtxAfter);
 197         return Maps.difference(vppNodesByL2FdBefore.asMap(), vppNodesByL2FdAfter.asMap());
 198     }
 199
 200     private void rendererPolicyCreated(RendererPolicy rPolicy) {
 201         PolicyContext policyCtx = new PolicyContext(rPolicy);
 202         ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
 203
 204         SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
 205         fwManager.createBridgeDomainOnNodes(vppNodesByL2Fd);
 206
 207         rEpKeys.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtx));
 208     }
 209
 210     private void rendererPolicyDeleted(RendererPolicy rendererPolicy) {
 211         PolicyContext policyCtx = new PolicyContext(rendererPolicy);
 212         ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
 213
 214         rEpKeys.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtx));
 215
 216         SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
 217         fwManager.removeBridgeDomainOnNodes(vppNodesByL2Fd);
 218     }
 219
 220     private static SetMultimap<String, NodeId> resolveVppNodesByL2Fd(Set<RendererEndpointKey> rEpKeys,
 221             PolicyContext policyCtx) {
 222         SetMultimap<String, NodeId> vppNodesByL2Fd = HashMultimap.create();
 223         rEpKeys.stream()
 224             .map(rEpKey -> KeyFactory.addressEndpointKey(rEpKey))
 225             .map(addrEpKey -> policyCtx.getAddrEpByKey().get(addrEpKey))
 226             .collect(Collectors.toSet())
 227             .forEach(addrEpWithLoc -> {
 228                 Optional<String> optL2Fd =
 229                         ForwardingManager.resolveL2FloodDomain(addrEpWithLoc.getNetworkContainment());
 230                 if (optL2Fd.isPresent()) {
 231                     ExternalLocationCase rEpLoc = ForwardingManager.resolveAndValidateLocation(addrEpWithLoc);
 232                     InstanceIdentifier<?> externalNodeMountPoint = rEpLoc.getExternalNodeMountPoint();
 233                     NodeId vppNode = externalNodeMountPoint.firstKeyOf(Node.class).getNodeId();
 234                     vppNodesByL2Fd.put(optL2Fd.get(), vppNode);
 235                 }
 236             });
 237         return vppNodesByL2Fd;
 238     }
 239
 240     @Subscribe
 241     public void vppNodeChanged(NodeOperEvent event) {
 242         switch (event.getDtoModificationType()) {
 243             case CREATED:
 244                 if (event.isAfterConnected()) {
 245                     // TODO
 246                 }
 247                 break;
 248             case UPDATED:
 249                 if (!event.isBeforeConnected() && event.isAfterConnected()) {
 250                     // TODO
 251                 }
 252                 break;
 253             case DELETED:
 254                 if (event.isBeforeConnected()) {
 255                     // TODO
 256                 }
 257                 break;
 258         }
 259     }
 260 }