2 * Copyright (c) 2015 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.ofoverlay.flow;
11 import com.google.common.base.Optional;
12 import com.google.common.base.Preconditions;
13 import com.google.common.util.concurrent.CheckedFuture;
14 import org.junit.Before;
15 import org.junit.Test;
16 import org.mockito.InOrder;
17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
18 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
20 import org.opendaylight.groupbasedpolicy.dto.EgKey;
21 import org.opendaylight.groupbasedpolicy.dto.PolicyInfo;
22 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfContext;
23 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.OfWriter;
24 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
25 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.mapper.MapperUtilsTest;
26 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
27 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.ovs.rev140701.Node;
28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextBuilder;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan;
40 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
42 import java.util.Collection;
43 import java.util.HashSet;
46 import static org.mockito.Mockito.any;
47 import static org.mockito.Mockito.atLeastOnce;
48 import static org.mockito.Mockito.eq;
49 import static org.mockito.Mockito.inOrder;
50 import static org.mockito.Mockito.mock;
51 import static org.mockito.Mockito.times;
52 import static org.mockito.Mockito.verify;
53 import static org.mockito.Mockito.verifyZeroInteractions;
54 import static org.mockito.Mockito.when;
56 public class GroupTableTest extends MapperUtilsTest {
58 private final GroupId GROUP_ID = new GroupId(27L);
59 private GroupTable groupTable;
61 private DataBroker dataBroker;
62 private ReadOnlyTransaction readOnlyTransaction;
63 private CheckedFuture checkedFutureFCNRead;
64 private Optional optionalFlowCapableNode;
65 private FlowCapableNode flowCapableNode;
69 ctx = mock(OfContext.class);
70 endpointManager = mock(EndpointManager.class);
71 switchManager = mock(SwitchManager.class);
72 policyInfo = mock(PolicyInfo.class);
73 groupTable = new GroupTable(ctx);
74 ofWriter = mock(OfWriter.class);
75 OrdinalFactory.resetPolicyOrdinalValue();
79 public void sync_noEpNodeId() throws Exception {
81 EndpointBuilder endpointBuilder = new EndpointBuilder();
82 Endpoint endpoint = endpointBuilder.build();
84 when(ctx.getEndpointManager()).thenReturn(endpointManager);
86 groupTable.sync(endpoint, ofWriter);
88 verifyZeroInteractions(ofWriter);
92 public void sync_nodeIsNotFlowCapable() throws Exception {
94 EndpointBuilder endpointBuilder = new EndpointBuilder();
95 OfOverlayContextBuilder ofOverlayContextBuilder = new OfOverlayContextBuilder();
96 ofOverlayContextBuilder.setNodeId(NODE_ID);
97 endpointBuilder.addAugmentation(OfOverlayContext.class, ofOverlayContextBuilder.build());
98 Endpoint endpoint = endpointBuilder.build();
100 when(ctx.getEndpointManager()).thenReturn(endpointManager);
101 when(ctx.getDataBroker()).thenReturn(dataBroker);
102 when(endpointManager.getEndpointNodeId(any(Endpoint.class))).thenCallRealMethod();
103 when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
104 when(readOnlyTransaction.read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class)))
105 .thenReturn(checkedFutureFCNRead);
106 when(checkedFutureFCNRead.get()).thenReturn(optionalFlowCapableNode);
107 when(optionalFlowCapableNode.isPresent()).thenReturn(true);
109 groupTable.sync(endpoint, ofWriter);
111 verify(optionalFlowCapableNode, times(1)).isPresent();
112 verifyZeroInteractions(ofWriter);
116 public void sync_nullOrdinals() throws Exception {
117 initDataStoreMocks();
118 EndpointBuilder endpointBuilder = new EndpointBuilder();
119 OfOverlayContextBuilder ofOverlayContextBuilder = new OfOverlayContextBuilder();
120 ofOverlayContextBuilder.setNodeId(NODE_ID);
121 endpointBuilder.addAugmentation(OfOverlayContext.class, ofOverlayContextBuilder.build());
122 Endpoint endpoint = endpointBuilder.build();
124 when(ctx.getEndpointManager()).thenReturn(endpointManager);
125 when(ctx.getDataBroker()).thenReturn(dataBroker);
126 when(endpointManager.getEndpointNodeId(any(Endpoint.class))).thenCallRealMethod();
127 when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
128 when(readOnlyTransaction.read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class)))
129 .thenReturn(checkedFutureFCNRead);
130 when(checkedFutureFCNRead.get()).thenReturn(optionalFlowCapableNode);
131 when(optionalFlowCapableNode.isPresent()).thenReturn(true);
132 when(optionalFlowCapableNode.get()).thenReturn(flowCapableNode);
134 groupTable.sync(endpoint, ofWriter);
136 verify(optionalFlowCapableNode, times(1)).isPresent();
137 verifyZeroInteractions(ofWriter);
141 public void sync() throws Exception {
142 initDataStoreMocks();
143 EndpointBuilder endpointBuilder = new EndpointBuilder();
144 OfOverlayContextBuilder ofOverlayContextBuilder = new OfOverlayContextBuilder();
145 ofOverlayContextBuilder.setNodeId(NODE_ID);
146 endpointBuilder.addAugmentation(OfOverlayContext.class, ofOverlayContextBuilder.build());
147 endpointBuilder.setNetworkContainment(NET_DOMAIN_ID);
148 endpointBuilder.setTenant(buildTenant().getId());
149 Endpoint endpoint = endpointBuilder.build();
151 when(ctx.getEndpointManager()).thenReturn(endpointManager);
152 when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
153 when(ctx.getDataBroker()).thenReturn(dataBroker);
154 when(ctx.getTenant(any(TenantId.class))).thenReturn(getTestIndexedTenant());
155 when(endpointManager.getEndpointNodeId(any(Endpoint.class))).thenCallRealMethod();
156 when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
157 when(readOnlyTransaction.read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class)))
158 .thenReturn(checkedFutureFCNRead);
159 when(checkedFutureFCNRead.get()).thenReturn(optionalFlowCapableNode);
160 when(optionalFlowCapableNode.isPresent()).thenReturn(true);
161 when(optionalFlowCapableNode.get()).thenReturn(flowCapableNode);
163 groupTable.sync(endpoint, ofWriter);
165 verify(optionalFlowCapableNode, times(1)).isPresent();
166 verify(ofWriter, times(1)).writeGroup(NODE_ID, new GroupId(0L));
170 public void syncGroups_groupsForNode() throws Exception {
172 NodeId nodeWithoutTunnel = new NodeId("nodeIdWithoutTunnel");
173 NodeId nodeIdIpV6 = new NodeId("nodeIdIpV6");
174 NodeId nodeIdIpV4 = new NodeId("nodeIdIpV4");
175 Endpoint endpoint = buildEndpoint(IPV4_0, MAC_0, new NodeConnectorId(OPENFLOW + CONNECTOR_0.getValue())).build();
177 when(ctx.getTenant(any(TenantId.class))).thenReturn(getTestIndexedTenant());
178 when(ctx.getEndpointManager()).thenReturn(endpointManager);
179 when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
181 OrdinalFactory.EndpointFwdCtxOrdinals ordinals = OrdinalFactory.getEndpointFwdCtxOrdinals(ctx, endpoint);
182 Preconditions.checkNotNull(ordinals);
185 Set<EgKey> egKeys = new HashSet<>();
186 egKeys.add(new EgKey(buildTenant().getId(), endpoint.getEndpointGroup()));
188 Set<NodeId> nodeIds = new HashSet<>();
189 nodeIds.add(NODE_ID);
190 nodeIds.add(nodeWithoutTunnel);
191 nodeIds.add(nodeIdIpV6);
192 nodeIds.add(nodeIdIpV4);
194 Collection<Endpoint> endpoints = new HashSet<>();
195 endpoints.add(buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1).build());
196 endpoints.add(buildEndpoint(IPV4_2, MAC_2, CONNECTOR_2).build());
198 when(ctx.getSwitchManager()).thenReturn(switchManager);
199 when(endpointManager.getGroupsForNode(NODE_ID)).thenReturn(egKeys);
200 when(endpointManager.getNodesForGroup(any(EgKey.class))).thenReturn(nodeIds);
201 when(endpointManager.getEndpointsForNode(any(NodeId.class))).thenReturn(endpoints);
202 when(switchManager.getTunnelIP(nodeIdIpV6, TunnelTypeVxlan.class)).thenReturn(new IpAddress(IPV6_1));
203 when(switchManager.getTunnelIP(nodeIdIpV4, TunnelTypeVxlan.class)).thenReturn(new IpAddress(IPV4_1));
204 when(switchManager.getTunnelPort(NODE_ID, TunnelTypeVxlan.class)).thenReturn(CONNECTOR_1);
205 when(policyInfo.getPeers(any(EgKey.class))).thenReturn(egKeys);
207 groupTable.syncGroups(NODE_ID, ordinals, endpoint, GROUP_ID, ofWriter);
209 // Verify method order
210 InOrder order = inOrder(endpointManager, policyInfo, switchManager, ofWriter);
211 order.verify(endpointManager, times(1)).getGroupsForNode(NODE_ID);
212 order.verify(endpointManager, times(1)).getNodesForGroup(any(EgKey.class));
213 order.verify(policyInfo, times(1)).getPeers(any(EgKey.class));
214 order.verify(endpointManager, times(1)).getNodesForGroup(any(EgKey.class));
215 order.verify(switchManager, times(1)).getTunnelIP(nodeWithoutTunnel, TunnelTypeVxlan.class);
216 order.verify(switchManager, times(1)).getTunnelPort(NODE_ID, TunnelTypeVxlan.class);
217 order.verify(switchManager, times(1)).getTunnelIP(any(NodeId.class), eq(TunnelTypeVxlan.class));
218 order.verify(switchManager, times(1)).getTunnelPort(NODE_ID, TunnelTypeVxlan.class);
219 order.verify(switchManager, times(1)).getTunnelIP(any(NodeId.class), eq(TunnelTypeVxlan.class));
220 order.verify(switchManager, times(1)).getTunnelPort(NODE_ID, TunnelTypeVxlan.class);
221 order.verify(ofWriter, atLeastOnce()).writeBucket(any(NodeId.class), any(GroupId.class), any(Bucket.class));
225 public void syncGroups_externalEpsWithoutLocation() throws Exception {
226 EndpointBuilder endpointBuilder = buildEndpoint(IPV4_0, MAC_0, new NodeConnectorId(OPENFLOW + CONNECTOR_0.getValue()));
227 endpointBuilder.setNetworkContainment(L2FD_ID);
228 Endpoint endpoint = endpointBuilder.build();
230 when(ctx.getTenant(any(TenantId.class))).thenReturn(getTestIndexedTenant());
231 when(ctx.getEndpointManager()).thenReturn(endpointManager);
232 when(ctx.getCurrentPolicy()).thenReturn(policyInfo);
234 OrdinalFactory.EndpointFwdCtxOrdinals ordinals = OrdinalFactory.getEndpointFwdCtxOrdinals(ctx, endpoint);
235 Preconditions.checkNotNull(ordinals);
237 Set<EgKey> egKeys = new HashSet<>();
238 egKeys.add(new EgKey(buildTenant().getId(), endpoint.getEndpointGroup()));
240 Set<NodeConnectorId> externalPorts = new HashSet<>();
241 externalPorts.add(new NodeConnectorId(OPENFLOW + CONNECTOR_1.getValue())); // Correct format
242 externalPorts.add(CONNECTOR_2); // NumberFormatException
244 Collection<Endpoint> endpoints = new HashSet<>();
245 EndpointBuilder noLocEndpointBuilder = buildEndpoint(IPV4_1, MAC_1, CONNECTOR_1);
246 noLocEndpointBuilder.setNetworkContainment(L2FD_ID);
247 endpoints.add(noLocEndpointBuilder.build());
249 when(ctx.getSwitchManager()).thenReturn(switchManager);
250 when(endpointManager.getGroupsForNode(NODE_ID)).thenReturn(egKeys);
251 when(endpointManager.getExtEpsNoLocForGroup(any(EgKey.class))).thenReturn(endpoints);
252 when(switchManager.getExternalPorts(NODE_ID)).thenReturn(externalPorts);
254 groupTable.syncGroups(NODE_ID, ordinals, endpoint, GROUP_ID, ofWriter);
256 // Verify method order
257 InOrder order = inOrder(endpointManager, policyInfo, switchManager, ofWriter);
258 order.verify(endpointManager, times(1)).getGroupsForNode(NODE_ID);
259 order.verify(endpointManager, times(1)).getExtEpsNoLocForGroup(any(EgKey.class));
260 order.verify(switchManager, times(1)).getExternalPorts(any(NodeId.class));
261 order.verify(ofWriter, times(1)).writeBucket(any(NodeId.class), any(GroupId.class), any(Bucket.class));
264 private void initDataStoreMocks() {
265 dataBroker = mock(DataBroker.class);
266 readOnlyTransaction = mock(ReadOnlyTransaction.class);
267 checkedFutureFCNRead = mock(CheckedFuture.class);
268 optionalFlowCapableNode = mock(Optional.class);
269 flowCapableNode = mock(FlowCapableNode.class);