2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
11 import java.util.Collection;
12 import java.util.HashSet;
14 import java.util.Map.Entry;
16 import java.util.stream.Collectors;
18 import javax.annotation.Nonnull;
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;
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;
53 public class VppRendererPolicyManager {
55 private static final Logger LOG = LoggerFactory.getLogger(VppRendererPolicyManager.class);
56 private final DataBroker dataProvider;
57 private ForwardingManager fwManager;
59 public VppRendererPolicyManager(@Nonnull ForwardingManager fwManager, @Nonnull DataBroker dataProvider) {
60 this.fwManager = Preconditions.checkNotNull(fwManager);
61 this.dataProvider = Preconditions.checkNotNull(dataProvider);
65 public void rendererPolicyChanged(RendererPolicyConfEvent event) {
66 RendererPolicyBuilder responseBuilder = new RendererPolicyBuilder();
67 switch (event.getDtoModificationType()) {
69 LOG.trace("CREATED : {}", event.getIid());
70 responseBuilder.setVersion(event.getAfter().get().getVersion());
71 rendererPolicyCreated(event.getAfter().get());
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());
82 // TODO collect unconfigured rules and put them to responseBuilder
83 rendererPolicyUpdated(rPolicyBefore, rPolicyAfter);
87 LOG.trace("DELETED: {}", event.getIid());
88 responseBuilder.setVersion(event.getBefore().get().getVersion());
89 rendererPolicyDeleted(event.getBefore().get());
92 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
93 RendererPolicy response = responseBuilder.build();
94 wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.rendererIid(VppRenderer.NAME).child(RendererPolicy.class),
96 Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
99 public void onSuccess(Void result) {
100 LOG.debug("Renderer updated renderer policy {}", response);
104 public void onFailure(Throwable t) {
105 LOG.warn("Renderer DIDN'T update renderer-policy {}", response);
110 private void rendererPolicyUpdated(RendererPolicy rPolicyBefore, RendererPolicy rPolicyAfter) {
111 PolicyContext policyCtxBefore = new PolicyContext(rPolicyBefore);
112 PolicyContext policyCtxAfter = new PolicyContext(rPolicyAfter);
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()
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);
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);
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);
151 ImmutableSet<RendererEndpointKey> rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet();
152 ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
154 SetView<RendererEndpointKey> removedRendEps = Sets.difference(rendEpsBefore, rendEpsAfter);
155 LOG.trace("Removed renderer endpoints {}", removedRendEps);
156 removedRendEps.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtxBefore));
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);
163 SetView<RendererEndpointKey> createdRendEps = Sets.difference(rendEpsAfter, rendEpsBefore);
164 LOG.trace("Created renderer endpoints {}", createdRendEps);
165 createdRendEps.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtxAfter));
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);
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);
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());
200 private void rendererPolicyCreated(RendererPolicy rPolicy) {
201 PolicyContext policyCtx = new PolicyContext(rPolicy);
202 ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
204 SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
205 fwManager.createBridgeDomainOnNodes(vppNodesByL2Fd);
207 rEpKeys.forEach(rEpKey -> fwManager.createForwardingForEndpoint(rEpKey, policyCtx));
210 private void rendererPolicyDeleted(RendererPolicy rendererPolicy) {
211 PolicyContext policyCtx = new PolicyContext(rendererPolicy);
212 ImmutableSet<RendererEndpointKey> rEpKeys = policyCtx.getPolicyTable().rowKeySet();
214 rEpKeys.forEach(rEpKey -> fwManager.removeForwardingForEndpoint(rEpKey, policyCtx));
216 SetMultimap<String, NodeId> vppNodesByL2Fd = resolveVppNodesByL2Fd(rEpKeys, policyCtx);
217 fwManager.removeBridgeDomainOnNodes(vppNodesByL2Fd);
220 private static SetMultimap<String, NodeId> resolveVppNodesByL2Fd(Set<RendererEndpointKey> rEpKeys,
221 PolicyContext policyCtx) {
222 SetMultimap<String, NodeId> vppNodesByL2Fd = HashMultimap.create();
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);
237 return vppNodesByL2Fd;
241 public void vppNodeChanged(NodeOperEvent event) {
242 switch (event.getDtoModificationType()) {
244 if (event.isAfterConnected()) {
249 if (!event.isBeforeConnected() && event.isAfterConnected()) {
254 if (event.isBeforeConnected()) {