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.AbstractMap;
12 import java.util.Arrays;
13 import java.util.Collection;
14 import java.util.List;
15 import java.util.concurrent.ExecutionException;
16 import java.util.concurrent.locks.ReentrantLock;
17 import java.util.stream.Collectors;
19 import org.junit.Assert;
20 import org.junit.Before;
21 import org.junit.Test;
22 import org.junit.runner.RunWith;
23 import org.mockito.Mockito;
24 import org.mockito.runners.MockitoJUnitRunner;
25 import org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppRenderer;
26 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
27 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
28 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
29 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
30 import org.opendaylight.groupbasedpolicy.renderer.vpp.DtoFactory;
31 import org.opendaylight.groupbasedpolicy.renderer.vpp.dhcp.DhcpRelayHandler;
32 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.RendererPolicyConfEvent;
33 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
34 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
35 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppEndpointLocationProvider;
36 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager;
37 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
38 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.loopback.LoopbackManager;
39 import org.opendaylight.groupbasedpolicy.renderer.vpp.nat.NatManager;
40 import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AclManager;
41 import org.opendaylight.groupbasedpolicy.renderer.vpp.routing.RoutingManager;
42 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
43 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
44 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
45 import org.opendaylight.groupbasedpolicy.util.IidFactory;
46 import org.opendaylight.vbd.impl.transaction.VbdNetconfTransaction;
47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessLists;
48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.L2FloodDomain;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationBuilder;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationKey;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCaseBuilder;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRef;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.BridgeDomains;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceAugmentation;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VxlanVni;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.L2;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.l2.config.attributes.Interconnection;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.l2.config.attributes.interconnection.BridgeBased;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev170327.TunnelTypeVxlan;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev170327.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;
83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
84 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
86 import com.google.common.base.Optional;
87 import com.google.common.base.Strings;
89 @RunWith(MockitoJUnitRunner.class)
90 public class VppRendererPolicyManagerTest extends CustomDataBrokerTest {
92 private static final InstanceIdentifier<RendererPolicy> RENDERER_POLICY_IID =
93 IidFactory.rendererIid(VppRenderer.NAME).child(RendererPolicy.class);
94 private final static String SOCKET = "socket";
96 private MountedDataBrokerProvider mountedDataProviderMock;
97 private DataBroker mountPointDataBroker;
98 private DataBroker dataBroker;
100 private BridgeDomainManagerImpl bdManager;
101 private InterfaceManager ifaceManager;
102 private AclManager aclManager;
103 private ForwardingManager fwManager;
104 private NatManager natManager;
105 private RoutingManager routingManager;
106 private LispStateManager lispStateManager;
107 private LoopbackManager loopbackManager;
108 private FlatOverlayManager flatOverlayManager;
109 private DhcpRelayHandler dhcpRelayHandler;
110 private VppRendererPolicyManager vppRendererPolicyManager;
113 public Collection<Class<?>> getClassesFromModules() {
114 return Arrays.asList(Node.class, VppEndpoint.class, Interfaces.class, BridgeDomains.class,
115 LocationProviders.class, L2FloodDomain.class, VxlanVni.class, TopologyVbridgeAugment.class,
116 TunnelTypeVxlan.class, PhysicalLocationRef.class, AccessLists.class,
117 VppInterfaceAugmentation.class, VppAclInterfaceAugmentation.class, VxlanTunnelParameters.class);
121 public void init() throws Exception {
122 mountedDataProviderMock = Mockito.mock(MountedDataBrokerProvider.class);
123 mountPointDataBroker = getDataBroker();
124 setup(); // initialize new data broker for ODL data store
125 dataBroker = getDataBroker();
126 Mockito.when(mountedDataProviderMock.resolveDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class)))
127 .thenReturn(Optional.of(mountPointDataBroker));
128 lispStateManager = new LispStateManager(mountedDataProviderMock);
129 loopbackManager = new LoopbackManager(mountedDataProviderMock);
130 flatOverlayManager = new FlatOverlayManager(dataBroker, mountedDataProviderMock);
131 ifaceManager = new InterfaceManager(mountedDataProviderMock, dataBroker, flatOverlayManager);
132 aclManager = new AclManager(mountedDataProviderMock, ifaceManager);
133 natManager = new NatManager(dataBroker, mountedDataProviderMock);
134 routingManager = new RoutingManager(dataBroker, mountedDataProviderMock);
135 bdManager = new BridgeDomainManagerImpl(mountPointDataBroker);
136 dhcpRelayHandler = new DhcpRelayHandler(dataBroker, mountedDataProviderMock);
137 fwManager = new ForwardingManager(ifaceManager, aclManager, natManager, routingManager, bdManager,
138 lispStateManager, loopbackManager, flatOverlayManager, dhcpRelayHandler, dataBroker);
139 vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, aclManager, dataBroker);
140 fwManager.setTimer((byte) 1);
141 VbdNetconfTransaction.NODE_DATA_BROKER_MAP.put(DtoFactory.VPP_NODE_1_IID,
142 new AbstractMap.SimpleEntry(mountPointDataBroker, new ReentrantLock()));
143 VbdNetconfTransaction.NODE_DATA_BROKER_MAP.put(DtoFactory.VPP_NODE_2_IID,
144 new AbstractMap.SimpleEntry(mountPointDataBroker, new ReentrantLock()));
148 public void testRendererPolicyChanged_created_oneEpPerEpg() throws Exception {
149 String clientIp = "1.1.1.1/32";
150 String clientIfaceName = "client1";
151 AbsoluteLocation clientLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, clientIfaceName);
152 AddressEndpointWithLocation clientEp =
153 DtoFactory.createEndpoint(clientIp, DtoFactory.L2FD_CTX.getValue(), clientLocation);
154 String webIp = "2.2.2.2/32";
155 String webIfaceName = "web1";
156 AbsoluteLocation webLocation = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, webIfaceName);
157 AddressEndpointWithLocation webEp =
158 DtoFactory.createEndpoint(webIp, DtoFactory.L2FD_CTX.getValue(), webLocation);
160 storeVppEndpoint(clientEp.getKey(), clientIfaceName, createVppEndpointIid(clientEp.getKey()));
161 storeVppEndpoint(webEp.getKey(), webIfaceName, createVppEndpointIid(webEp.getKey()));
163 Configuration configuration = DtoFactory.createConfiguration(Arrays.asList(clientEp), Arrays.asList(webEp));
164 RendererPolicy rendererPolicy =
165 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
166 RendererPolicyConfEvent event = new RendererPolicyConfEvent(RENDERER_POLICY_IID, null, rendererPolicy);
168 vppRendererPolicyManager.rendererPolicyChanged(event);
170 // assert state on data store behind mount point
171 Interface clientIface = readAndAssertInterface(clientIfaceName);
172 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), clientIface);
173 Interface webIface = readAndAssertInterface(webIfaceName);
174 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), webIface);
175 // assert state on ODL data store
176 ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
177 Optional<LocationProvider> optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION,
178 IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER))
180 Assert.assertTrue(optLocationProvider.isPresent());
181 System.out.println("DEBUGG " + optLocationProvider.get());
182 List<ProviderAddressEndpointLocation> epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
183 Assert.assertNotNull(epLocs);
184 Assert.assertEquals(2, epLocs.size());
185 assertProviderAddressEndpointLocation(clientEp.getKey(),
186 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, DtoFactory.L2FD_CTX.getValue(), clientIfaceName),
188 assertProviderAddressEndpointLocation(webEp.getKey(),
189 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, DtoFactory.L2FD_CTX.getValue(), webIfaceName),
194 public void testRendererPolicyChanged_update() throws Exception {
195 String client1IfaceName = "client1";
196 AbsoluteLocation client1LocationNodeNull =
197 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, client1IfaceName);
198 AddressEndpointWithLocation client1Ep =
199 DtoFactory.createEndpoint("10.0.0.1/32", DtoFactory.L2FD_CTX.getValue(), client1LocationNodeNull);
200 String web1IfaceName = "web1";
201 AbsoluteLocation web1LocationNodeNull =
202 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, null, web1IfaceName);
203 AddressEndpointWithLocation web1Ep =
204 DtoFactory.createEndpoint("20.0.0.1/32", DtoFactory.L2FD_CTX.getValue(), web1LocationNodeNull);
205 String client2IfaceName = "client2";
206 AbsoluteLocation client2LocationNodeNull =
207 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID, null, client2IfaceName);
208 AddressEndpointWithLocation client2Ep =
209 DtoFactory.createEndpoint("10.0.0.2/32", DtoFactory.L2FD_CTX.getValue(), client2LocationNodeNull);
210 String web2IfaceName = "web2";
211 AbsoluteLocation web2LocationNodeNull =
212 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, null, web2IfaceName);
213 AddressEndpointWithLocation web2Ep =
214 DtoFactory.createEndpoint("20.0.0.2/32", DtoFactory.L2FD_CTX.getValue(), web2LocationNodeNull);
216 storeVppEndpoint(client1Ep.getKey(), client1IfaceName, createVppEndpointIid(client1Ep.getKey()));
217 storeVppEndpoint(web1Ep.getKey(), web1IfaceName, createVppEndpointIid(web1Ep.getKey()));
218 storeVppEndpoint(client2Ep.getKey(), client2IfaceName, createVppEndpointIid(client2Ep.getKey()));
219 storeVppEndpoint(web2Ep.getKey(), web2IfaceName, createVppEndpointIid(web2Ep.getKey()));
221 Configuration configuration =
222 DtoFactory.createConfiguration(Arrays.asList(client1Ep, client2Ep), Arrays.asList(web1Ep, web2Ep));
223 RendererPolicy rendererPolicy =
224 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
225 RendererPolicyConfEvent event = new RendererPolicyConfEvent(RENDERER_POLICY_IID, null, rendererPolicy);
227 vppRendererPolicyManager.rendererPolicyChanged(event);
229 // assert state on data store behind mount point ######################################
230 Interface client1Iface = readAndAssertInterface(client1IfaceName);
231 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), client1Iface);
232 Interface web1Iface = readAndAssertInterface(web1IfaceName);
233 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), web1Iface);
234 Interface client2Iface = readAndAssertInterface(client2IfaceName);
235 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), client2Iface);
236 Interface web2Iface = readAndAssertInterface(web2IfaceName);
237 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), web2Iface);
238 // assert state on ODL data store
239 ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
240 Optional<LocationProvider> optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION,
241 IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER))
243 Assert.assertTrue(optLocationProvider.isPresent());
244 List<ProviderAddressEndpointLocation> epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
245 Assert.assertNotNull(epLocs);
246 Assert.assertEquals(4, epLocs.size());
247 assertProviderAddressEndpointLocation(client1Ep.getKey(), DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
248 DtoFactory.L2FD_CTX.getValue(), client1IfaceName), epLocs);
249 assertProviderAddressEndpointLocation(web1Ep.getKey(),
250 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web1IfaceName),
252 assertProviderAddressEndpointLocation(client2Ep.getKey(), DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
253 DtoFactory.L2FD_CTX.getValue(), client2IfaceName), epLocs);
254 assertProviderAddressEndpointLocation(web2Ep.getKey(),
255 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web2IfaceName),
257 // #####################################################################################
259 AbsoluteLocation client1Location = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
260 DtoFactory.L2FD_CTX.getValue(), client1IfaceName);
261 AbsoluteLocation web1Location =
262 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web1IfaceName);
263 AbsoluteLocation web2Location =
264 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web2IfaceName);
265 configuration = DtoFactory.createConfiguration(
266 Arrays.asList(new AddressEndpointWithLocationBuilder(client1Ep).setAbsoluteLocation(client1Location)
268 new AddressEndpointWithLocationBuilder(client2Ep).setAbsoluteLocation(client2LocationNodeNull)
270 Arrays.asList(new AddressEndpointWithLocationBuilder(web1Ep).setAbsoluteLocation(web1Location).build(),
271 new AddressEndpointWithLocationBuilder(web2Ep).setAbsoluteLocation(web2Location).build()));
272 RendererPolicy rendererPolicy2 =
273 new RendererPolicyBuilder().setVersion(2L).setConfiguration(configuration).build();
274 RendererPolicyConfEvent event2 =
275 new RendererPolicyConfEvent(RENDERER_POLICY_IID, rendererPolicy, rendererPolicy2);
277 vppRendererPolicyManager.rendererPolicyChanged(event2);
279 // assert state on data store behind mount point ######################################
280 client1Iface = readAndAssertInterface(client1IfaceName);
281 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), client1Iface);
282 web1Iface = readAndAssertInterface(web1IfaceName);
283 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), web1Iface);
284 client2Iface = readAndAssertInterface(client2IfaceName);
285 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), client2Iface);
286 web2Iface = readAndAssertInterface(web2IfaceName);
287 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), web2Iface);
288 // assert state on ODL data store
289 rTx = dataBroker.newReadOnlyTransaction();
290 optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION,
291 IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER))
293 Assert.assertTrue(optLocationProvider.isPresent());
294 epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
295 Assert.assertNotNull(epLocs);
296 Assert.assertEquals(4, epLocs.size());
297 assertProviderAddressEndpointLocation(client1Ep.getKey(), DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
298 DtoFactory.L2FD_CTX.getValue(), client1IfaceName), epLocs);
299 assertProviderAddressEndpointLocation(web1Ep.getKey(),
300 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web1IfaceName),
302 assertProviderAddressEndpointLocation(client2Ep.getKey(), DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
303 DtoFactory.L2FD_CTX.getValue(), client2IfaceName), epLocs);
304 assertProviderAddressEndpointLocation(web2Ep.getKey(),
305 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web2IfaceName),
307 // #####################################################################################
309 AbsoluteLocation client2Location = DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
310 DtoFactory.L2FD_CTX.getValue(), client2IfaceName);
311 configuration = DtoFactory.createConfiguration(
312 Arrays.asList(new AddressEndpointWithLocationBuilder(client1Ep).setAbsoluteLocation(client1Location)
314 new AddressEndpointWithLocationBuilder(client2Ep).setAbsoluteLocation(client2Location).build()),
315 Arrays.asList(new AddressEndpointWithLocationBuilder(web1Ep).setAbsoluteLocation(web1Location).build(),
316 new AddressEndpointWithLocationBuilder(web2Ep).setAbsoluteLocation(web2Location).build()));
317 RendererPolicy rendererPolicy3 =
318 new RendererPolicyBuilder().setVersion(3L).setConfiguration(configuration).build();
319 RendererPolicyConfEvent event3 =
320 new RendererPolicyConfEvent(RENDERER_POLICY_IID, rendererPolicy2, rendererPolicy3);
322 vppRendererPolicyManager.rendererPolicyChanged(event3);
324 // assert state on data store behind mount point ######################################
325 client1Iface = readAndAssertInterface(client1IfaceName);
326 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), client1Iface);
327 web1Iface = readAndAssertInterface(web1IfaceName);
328 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), web1Iface);
329 client2Iface = readAndAssertInterface(client2IfaceName);
330 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), client2Iface);
331 web2Iface = readAndAssertInterface(web2IfaceName);
332 assertBridgeDomainOnInterface(DtoFactory.L2FD_CTX.getValue(), web2Iface);
333 // assert state on ODL data store
334 rTx = dataBroker.newReadOnlyTransaction();
335 optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION,
336 IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER))
338 Assert.assertTrue(optLocationProvider.isPresent());
339 epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
340 Assert.assertNotNull(epLocs);
341 Assert.assertEquals(4, epLocs.size());
342 assertProviderAddressEndpointLocation(client1Ep.getKey(), DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
343 DtoFactory.L2FD_CTX.getValue(), client1IfaceName), epLocs);
344 assertProviderAddressEndpointLocation(web1Ep.getKey(),
345 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web1IfaceName),
347 assertProviderAddressEndpointLocation(client2Ep.getKey(), DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_1_IID,
348 DtoFactory.L2FD_CTX.getValue(), client2IfaceName), epLocs);
349 assertProviderAddressEndpointLocation(web2Ep.getKey(),
350 DtoFactory.absoluteLocation(DtoFactory.VPP_NODE_2_IID, DtoFactory.L2FD_CTX.getValue(), web2IfaceName),
352 // #####################################################################################
355 private InstanceIdentifier<VppEndpoint> createVppEndpointIid(AddressEndpointWithLocationKey key) {
356 return InstanceIdentifier.builder(Config.class)
357 .child(VppEndpoint.class, new VppEndpointKey(key.getAddress(), key.getAddressType(), key.getContextId(),
358 key.getContextType()))
362 private void assertProviderAddressEndpointLocation(AddressEndpointWithLocationKey expectedEpKey,
363 AbsoluteLocation expectedEpLoc, List<ProviderAddressEndpointLocation> providerEpLocs) {
364 List<ProviderAddressEndpointLocation> expectedProvEpLoc =
365 providerEpLocs.stream()
366 .filter(provEpLoc -> provEpLoc.getKey()
367 .equals(KeyFactory.providerAddressEndpointLocationKey(expectedEpKey)))
368 .collect(Collectors.toList());
369 Assert.assertFalse(expectedProvEpLoc.isEmpty());
370 Assert.assertEquals(1, expectedProvEpLoc.size());
371 Assert.assertEquals(expectedEpLoc, expectedProvEpLoc.get(0).getAbsoluteLocation());
374 private Interface readAndAssertInterface(String expectedInterface) throws Exception {
375 ReadOnlyTransaction rTxMount = mountPointDataBroker.newReadOnlyTransaction();
376 Optional<Interface> potentialIface = rTxMount.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier
377 .builder(Interfaces.class).child(Interface.class, new InterfaceKey(expectedInterface)).build()).get();
378 Assert.assertTrue(potentialIface.isPresent());
379 return potentialIface.get();
382 private static void assertBridgeDomainOnInterface(String expectedBridgeDomain, Interface actualIface) {
383 VppInterfaceAugmentation vppIfaceAug = actualIface.getAugmentation(VppInterfaceAugmentation.class);
384 Assert.assertNotNull(vppIfaceAug);
385 if (!Strings.isNullOrEmpty(expectedBridgeDomain)) {
386 Interconnection interconnection = vppIfaceAug.getL2().getInterconnection();
387 Assert.assertNotNull(interconnection);
388 Assert.assertTrue(interconnection instanceof BridgeBased);
389 Assert.assertEquals(expectedBridgeDomain, ((BridgeBased) interconnection).getBridgeDomain());
391 if (vppIfaceAug != null) {
392 L2 l2 = vppIfaceAug.getL2();
394 Assert.assertNull(l2.getInterconnection());
400 private void storeVppEndpoint(AddressEndpointWithLocationKey clientEp, String ifaceName,
401 InstanceIdentifier<VppEndpoint> vppEpIid) {
402 AddressEndpoint addrEp = new AddressEndpointBuilder().setKey(new AddressEndpointKey(clientEp.getAddress(),
403 clientEp.getAddressType(), clientEp.getContextId(), clientEp.getContextType()))
405 InstanceIdentifier<AddressEndpoint> iid = InstanceIdentifier.create(Endpoints.class)
406 .child(AddressEndpoints.class)
407 .child(AddressEndpoint.class, addrEp.getKey());
408 WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
409 wTx.put(LogicalDatastoreType.OPERATIONAL, iid, addrEp);
412 } catch (InterruptedException | ExecutionException e) {
416 VppEndpoint vhostEp = new VppEndpointBuilder().setAddress(clientEp.getAddress())
417 .setAddressType(clientEp.getAddressType())
418 .setContextId(clientEp.getContextId())
419 .setContextType(clientEp.getContextType())
420 .setVppInterfaceName(ifaceName)
421 .setVppNodeId(DtoFactory.VPP_NODE_1_IID.firstKeyOf(Node.class).getNodeId())
422 .setInterfaceTypeChoice(new VhostUserCaseBuilder().setSocket(SOCKET).build())
424 VppEndpointConfEvent vppEpEvent = new VppEndpointConfEvent(vppEpIid, null, vhostEp);
425 ifaceManager.vppEndpointChanged(vppEpEvent);