interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/InterfaceManagerConfigurationTest.java

   1 /*
   2  * Copyright (c) 2016, 2017 Red Hat, 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 package org.opendaylight.genius.interfacemanager.test;
   9
  10 import static java.util.concurrent.TimeUnit.MINUTES;
  11 import static org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.BatchingUtils.EntityType.DEFAULT_OPERATIONAL;
  12 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.DPN_ID_1;
  13 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.DPN_ID_2;
  14 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.INTERFACE_NAME;
  15 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.INTERFACE_NAME_1;
  16 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.INTERFACE_NAME_2;
  17 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.PARENT_INTERFACE;
  18 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.PARENT_INTERFACE_1;
  19 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.PARENT_INTERFACE_2;
  20 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.PORT_NO_1;
  21 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.TRUNK_INTERFACE_NAME;
  22 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.TUNNEL_INTERFACE_NAME;
  23 import static org.opendaylight.genius.interfacemanager.test.InterfaceManagerTestUtil.waitTillOperationCompletes;
  24 import static org.opendaylight.genius.mdsalutil.NwConstants.DEFAULT_EGRESS_SERVICE_INDEX;
  25 import static org.opendaylight.genius.mdsalutil.NwConstants.VLAN_INTERFACE_INGRESS_TABLE;
  26 import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
  27 import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
  28 import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
  29
  30 import java.util.ArrayList;
  31 import java.util.Comparator;
  32 import java.util.List;
  33 import java.util.Optional;
  34 import java.util.concurrent.ExecutionException;
  35 import java.util.concurrent.Future;
  36 import javax.inject.Inject;
  37 import org.junit.After;
  38 import org.junit.Assert;
  39 import org.junit.Before;
  40 import org.junit.Ignore;
  41 import org.junit.Rule;
  42 import org.junit.Test;
  43 import org.junit.rules.MethodRule;
  44 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  45 import org.opendaylight.genius.datastoreutils.testutils.AsyncEventsWaiter;
  46 import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorCountedEventsWaiter;
  47 import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
  48 import org.opendaylight.genius.datastoreutils.testutils.TestableDataTreeChangeListenerModule;
  49 import org.opendaylight.genius.interfacemanager.IfmUtil;
  50 import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
  51 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
  52 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  53 import org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.BatchingUtils;
  54 import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
  55 import org.opendaylight.genius.interfacemanager.test.xtend.DpnFromInterfaceOutput;
  56 import org.opendaylight.genius.interfacemanager.test.xtend.EgressActionsForInterfaceOutput;
  57 import org.opendaylight.genius.interfacemanager.test.xtend.EgressInstructionsForInterfaceOutput;
  58 import org.opendaylight.genius.interfacemanager.test.xtend.EndPointIpFromDpn;
  59 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedBoundServiceState;
  60 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedFlowEntries;
  61 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedInterfaceChildEntry;
  62 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedInterfaceConfig;
  63 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedInterfaceInfo;
  64 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedInterfaceListFromDpn;
  65 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedInterfaceState;
  66 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedOvsdbBridge;
  67 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedServicesInfo;
  68 import org.opendaylight.genius.interfacemanager.test.xtend.ExpectedTerminationPoint;
  69 import org.opendaylight.genius.interfacemanager.test.xtend.InterfaceMeta;
  70 import org.opendaylight.genius.interfacemanager.test.xtend.InterfaceTypeOutput;
  71 import org.opendaylight.genius.interfacemanager.test.xtend.NodeconnectorIdFromInterfaceOutput;
  72 import org.opendaylight.genius.interfacemanager.test.xtend.PortFromInterfaceOutput;
  73 import org.opendaylight.genius.interfacemanager.test.xtend.TunnelTypeOutput;
  74 import org.opendaylight.genius.mdsalutil.NwConstants;
  75 import org.opendaylight.genius.mdsalutil.interfaces.testutils.FlowAssertTestUtils;
  76 import org.opendaylight.genius.utils.ServiceIndex;
  77 import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
  78 import org.opendaylight.infrautils.testutils.LogCaptureRule;
  79 import org.opendaylight.infrautils.testutils.LogRule;
  80 import org.opendaylight.infrautils.testutils.concurrent.TestableQueues;
  81 import org.opendaylight.mdsal.binding.api.DataBroker;
  82 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  83 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  84 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
  85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Tunnel;
  86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
  87 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.DpnToInterfaceList;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info.InterfaceParentEntryKey;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntry;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.BridgeEntryKey;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge._interface.info.bridge.entry.BridgeInterfaceEntryKey;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntryKey;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterface;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.DpnToInterfaceKey;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntry;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntryBuilder;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.dpn.to._interface.list.dpn.to._interface.InterfaceNameEntryKey;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInput;
 112 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInputBuilder;
 113 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
 114 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpnInterfaceListInput;
 115 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpnInterfaceListInputBuilder;
 116 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpnInterfaceListOutput;
 117 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInput;
 118 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceInputBuilder;
 119 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressActionsForInterfaceOutput;
 120 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressInstructionsForInterfaceInput;
 121 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressInstructionsForInterfaceInputBuilder;
 122 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEgressInstructionsForInterfaceOutput;
 123 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnInput;
 124 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnInputBuilder;
 125 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetEndpointIpForDpnOutput;
 126 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceTypeInput;
 127 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceTypeInputBuilder;
 128 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceTypeOutput;
 129 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInput;
 130 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceInputBuilder;
 131 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetNodeconnectorIdFromInterfaceOutput;
 132 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInput;
 133 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInputBuilder;
 134 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
 135 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetTunnelTypeInput;
 136 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetTunnelTypeInputBuilder;
 137 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetTunnelTypeOutput;
 138 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
 139 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.get.dpn._interface.list.output.Interfaces;
 140 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
 141 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeEgress;
 142 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
 143 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfo;
 144 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.ServicesInfoKey;
 145 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
 146 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesKey;
 147 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
 148 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
 149 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 150 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
 151 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
 152 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
 153 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
 154 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
 155 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
 156 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
 157 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 158 import org.opendaylight.yangtools.yang.common.RpcResult;
 159 import org.opendaylight.yangtools.yang.common.Uint64;
 160
 161 /**
 162  * Component tests for interface manager.
 163  *
 164  * @author Michael Vorburger
 165  * @author Faseela K
 166  */
 167 @SuppressWarnings("deprecation")
 168 public class InterfaceManagerConfigurationTest {
 169
 170     // Uncomment this, temporarily (never commit!), to see concurrency issues:
 171     // public static @ClassRule RunUntilFailureClassRule classRepeater = new RunUntilFailureClassRule();
 172     // public @Rule RunUntilFailureRule repeater = new RunUntilFailureRule(classRepeater);
 173
 174     public @Rule LogRule logRule = new LogRule();
 175     public @Rule LogCaptureRule logCaptureRule = new LogCaptureRule();
 176
 177     public @Rule MethodRule guice = new GuiceRule(InterfaceManagerTestModule.class,
 178         TestableDataTreeChangeListenerModule.class, JobCoordinatorTestModule.class);
 179
 180     @Inject DataBroker dataBroker;
 181     @Inject OdlInterfaceRpcService odlInterfaceRpcService;
 182     @Inject IInterfaceManager interfaceManager;
 183     @Inject JobCoordinatorCountedEventsWaiter coordinatorEventsWaiter;
 184     @Inject AsyncEventsWaiter asyncEventsWaiter;
 185     @Inject InterfaceMetaUtils interfaceMetaUtils;
 186     @Inject BatchingUtils batchingUtils;
 187     @Inject FlowAssertTestUtils flowAssertTestUtils;
 188
 189     SingleTransactionDataBroker db;
 190
 191     @Before
 192     public void start() throws InterruptedException, ExecutionException {
 193         db = new SingleTransactionDataBroker(dataBroker);
 194
 195         // Create the bridge and make sure it is ready
 196         setupAndAssertBridgeCreation();
 197     }
 198
 199     @After
 200     public void stop() throws InterruptedException, ExecutionException {
 201         setupAndAssertBridgeDeletion();
 202     }
 203
 204     private void setupAndAssertBridgeDeletion() throws InterruptedException, ExecutionException {
 205         OvsdbSouthboundTestUtil.deleteBridge(dataBroker);
 206         InterfaceManagerTestUtil.waitTillOperationCompletes("bridge deletion",
 207                 coordinatorEventsWaiter,2, asyncEventsWaiter);
 208         assertEqualBeans(interfaceMetaUtils.getBridgeRefEntryFromOperationalDS(DPN_ID_1), null);
 209     }
 210
 211     private void setupAndAssertBridgeCreation() throws InterruptedException, ExecutionException {
 212         OvsdbSouthboundTestUtil.createBridge(dataBroker);
 213         // a) Check bridgeRefEntry in cache and OperDS are same and use the
 214         // right DPN_ID
 215         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(DPN_ID_1);
 216         InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
 217                 .getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 218         InterfaceManagerTestUtil.waitTillOperationCompletes("bridge creation",
 219                 coordinatorEventsWaiter,3, asyncEventsWaiter);
 220         BridgeRefEntry bridgeRefEntry = IfmUtil
 221                 .read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker)
 222                 .orElse(null);
 223         assertEqualBeans(bridgeRefEntry.getDpid(), DPN_ID_1);
 224         // FIXME AsyncEventsWaiter does not help in this case, need to enhance -- TODO
 225         //assertEqualBeans(interfaceMetaUtils.getBridgeRefEntryFromCache(DPN_ID_1), bridgeRefEntry);
 226
 227     }
 228
 229     @Test
 230     public void testBinding() {
 231
 232     }
 233
 234     @Test
 235     @Ignore // TODO re-enable when stable, see https://jira.opendaylight.org/browse/GENIUS-120
 236     public void newl2vlanInterfaceTests() throws Exception {
 237         // 1. When
 238         // i) parent-interface specified in above vlan configuration comes in operational/ietf-interfaces-state
 239         OvsdbSouthboundTestUtil.createTerminationPoint(dataBroker, PARENT_INTERFACE, null, INTERFACE_NAME);
 240         InterfaceManagerTestUtil.createFlowCapableNodeConnector(dataBroker, PARENT_INTERFACE, null);
 241
 242         // ii) Vlan interface written to config/ietf-interfaces DS and
 243         // corresponding parent-interface is not present
 244         // in operational/ietf-interface-state
 245         ParentRefs parentRefs = new ParentRefsBuilder().setParentInterface(PARENT_INTERFACE).build();
 246         InterfaceManagerTestUtil.putInterfaceConfig(dataBroker, INTERFACE_NAME, parentRefs, L2vlan.class);
 247
 248         InterfaceManagerTestUtil.waitTillOperationCompletes("create interface configuration",
 249                 coordinatorEventsWaiter,11, asyncEventsWaiter);
 250
 251         // 3. Then
 252         // a) check expected interface-child entry mapping in
 253         // odl-interface-meta/config/interface-child-info was created
 254         InstanceIdentifier<InterfaceChildEntry> interfaceChildEntryInstanceIdentifier = InterfaceMetaUtils
 255                 .getInterfaceChildEntryIdentifier(new InterfaceParentEntryKey(PARENT_INTERFACE),
 256                         new InterfaceChildEntryKey(INTERFACE_NAME));
 257         assertEqualBeans(ExpectedInterfaceChildEntry.interfaceChildEntry(INTERFACE_NAME),
 258                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
 259                         interfaceChildEntryInstanceIdentifier).get());
 260
 261         // Then
 262         // a) check if operational/ietf-interfaces-state is populated for the vlan interface
 263         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 264             .interfaces.state.Interface ifaceState =
 265                 dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 266                 IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get().get();
 267
 268         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
 269             INTERFACE_NAME, Interface.OperStatus.Up, L2vlan.class, DPN_ID_1.toString(),
 270                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 271
 272
 273         // FIXME can assert this only once ResourceBatchingManager becomes testable
 274         // b) check if lport-tag to interface mapping is created
 275         /*(InstanceIdentifier<IfIndexInterface> ifIndexInterfaceInstanceIdentifier = InstanceIdentifier
 276                 .builder(IfIndexesInterfaceMap.class)
 277                 .child(IfIndexInterface.class, new IfIndexInterfaceKey(ifaceState.getIfIndex())).build();
 278         Assert.assertEquals(INTERFACE_NAME, dataBroker.newReadOnlyTransaction()
 279                 .read(OPERATIONAL, ifIndexInterfaceInstanceIdentifier).get().getInterfaceName());*/
 280
 281         // c) check expected flow entries were created in Interface Ingress
 282         // Table
 283         Uint64 dpnId = Uint64.ONE;
 284         String ingressFlowRef = FlowBasedServicesUtils.getFlowRef(VLAN_INTERFACE_INGRESS_TABLE, dpnId, INTERFACE_NAME);
 285         FlowKey ingressFlowKey = new FlowKey(new FlowId(ingressFlowRef));
 286         Node nodeDpn = InterfaceManagerTestUtil.buildInventoryDpnNode(dpnId);
 287         InstanceIdentifier<Flow> ingressFlowInstanceId = InstanceIdentifier.builder(Nodes.class)
 288                 .child(Node.class, nodeDpn.key()).augmentation(FlowCapableNode.class)
 289                 .child(Table.class, new TableKey(VLAN_INTERFACE_INGRESS_TABLE)).child(Flow.class, ingressFlowKey)
 290                 .build();
 291
 292         flowAssertTestUtils.assertFlowsInAnyOrder(ExpectedFlowEntries.newIngressFlow(),
 293                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION, ingressFlowInstanceId).get().get());
 294
 295         // d) check if default egress service is bound on the interface
 296         InstanceIdentifier<BoundServices> boundServicesInstanceIdentifier = InstanceIdentifier
 297                 .builder(ServiceBindings.class)
 298                 .child(ServicesInfo.class, new ServicesInfoKey(INTERFACE_NAME, ServiceModeEgress.class))
 299                 .child(BoundServices.class, new BoundServicesKey(DEFAULT_EGRESS_SERVICE_INDEX)).build();
 300         assertEqualBeans(ExpectedServicesInfo.newboundService(), dataBroker.newReadOnlyTransaction()
 301                 .read(CONFIGURATION, boundServicesInstanceIdentifier).get());
 302
 303         // Test all RPCs related to vlan-interfaces
 304         checkVlanRpcs();
 305
 306         // Test all APIs exposed by interface-manager
 307         checkVlanApis();
 308
 309         //Update config test
 310         // i) vlan interface admin-state updated
 311         InterfaceManagerTestUtil.updateInterfaceAdminState(dataBroker, INTERFACE_NAME, false);
 312
 313         InterfaceManagerTestUtil.waitTillOperationCompletes("disable interface admin state",
 314                 coordinatorEventsWaiter, 1, asyncEventsWaiter);
 315         // Then
 316         // a) check if operational/ietf-interfaces-state is updated for vlan interface
 317         ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 318             IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get().get();
 319         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(), INTERFACE_NAME, Interface
 320             .OperStatus.Down, L2vlan.class, DPN_ID_1.toString(),
 321                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 322
 323         // Restore the opState back to UP for proceeding with further tests
 324         InterfaceManagerTestUtil.updateInterfaceAdminState(dataBroker, INTERFACE_NAME, true);
 325         InterfaceManagerTestUtil.waitTillOperationCompletes("enable interface admin state",
 326                 coordinatorEventsWaiter, 1, asyncEventsWaiter);
 327
 328
 329         //state modification tests
 330         // 1. Make the operational state of port as DOWN
 331         InterfaceManagerTestUtil.updateFlowCapableNodeConnectorState(dataBroker, PARENT_INTERFACE, L2vlan.class, false);
 332         waitTillOperationCompletes("disable interface op state", coordinatorEventsWaiter, 2, asyncEventsWaiter);
 333
 334         ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 335             IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get().get();
 336         // Verify if operational/ietf-interface-state is marked down
 337         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
 338             INTERFACE_NAME, Interface.OperStatus.Down, L2vlan.class, DPN_ID_1.toString(),
 339                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 340
 341         // 4. Delete the southbound OF port
 342         InterfaceManagerTestUtil.removeFlowCapableNodeConnectorState(dataBroker, L2vlan.class);
 343         waitTillOperationCompletes("remove flow capable node connector",
 344                 coordinatorEventsWaiter, 5, asyncEventsWaiter);
 345
 346         // Verify if interfaces are deleted from oper/ietf-interfaces-state
 347         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 348             IfmUtil.buildStateInterfaceId(PARENT_INTERFACE)).get());
 349         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 350             IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get());
 351
 352         // 3. Re-create the OF port to proceeed with vlan-member tests
 353         InterfaceManagerTestUtil.createFlowCapableNodeConnector(dataBroker, PARENT_INTERFACE, null);
 354         waitTillOperationCompletes("remove flow capable node connector",
 355                 coordinatorEventsWaiter, 7, asyncEventsWaiter);
 356
 357         testVlanMemberInterface();
 358
 359         //Delete test
 360         // iii) vlan interface is deleted from config/ietf-interfaces
 361         InterfaceManagerTestUtil.deleteInterfaceConfig(dataBroker, INTERFACE_NAME);
 362         InterfaceManagerTestUtil.waitTillOperationCompletes("delete interface configuration",
 363                 coordinatorEventsWaiter, 6, asyncEventsWaiter);
 364         // 3. Then
 365         // a) check expected interface-child entry mapping in
 366         // odl-interface-meta/config/interface-child-info is deleted
 367
 368         // TODO Later use nicer abstraction for DB access here.. see
 369         // ElanServiceTest
 370         Assert.assertEquals(Optional.empty(),
 371                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION, interfaceChildEntryInstanceIdentifier).get());
 372
 373         // Then
 374         // a) check if operational/ietf-interfaces-state is deleted for the vlan
 375         // interface
 376         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
 377                 .read(OPERATIONAL, IfmUtil.buildStateInterfaceId(INTERFACE_NAME)).get());
 378
 379         // b) check if lport-tag to interface mapping is deleted
 380         /*Assert.assertEquals(Optional.empty(),
 381                 dataBroker.newReadOnlyTransaction().read(OPERATIONAL, ifIndexInterfaceInstanceIdentifier).get());*/
 382     }
 383
 384     @Ignore
 385     @Test
 386     public void newTunnelInterface() throws Exception {
 387         // 3. Update DPN-ID of the bridge
 388         OvsdbSouthboundTestUtil.updateBridge(dataBroker, "00:00:00:00:00:00:00:02");
 389         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 390         BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(DPN_ID_2);
 391         InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
 392             .getBridgeRefEntryIdentifier(bridgeRefEntryKey);
 393         // Verify if DPN-ID is updated in corresponding DS and cache
 394         BridgeRefEntry bridgeRefEntry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, bridgeRefEntryIid, dataBroker)
 395             .orElse(null);
 396         assertEqualBeans(interfaceMetaUtils.getBridgeRefEntryFromCache(DPN_ID_2), bridgeRefEntry);
 397
 398         // 1. Given
 399         // 2. When
 400         // i) dpn-id specified above configuration comes in
 401         // operational/network-topology
 402         // ii) Vlan interface written to config/ietf-interfaces DS and
 403         // corresponding parent-interface is not present
 404         // in operational/ietf-interface-state
 405         ParentRefs parentRefs = new ParentRefsBuilder().setDatapathNodeIdentifier(DPN_ID_2).build();
 406         InterfaceManagerTestUtil.putInterfaceConfig(dataBroker, TUNNEL_INTERFACE_NAME, parentRefs, Tunnel.class);
 407         Thread.sleep(5000);
 408
 409         // 3. Then
 410         // a) check expected bridge-interface mapping in
 411         // odl-interface-meta/config/bridge-interface-info was created
 412         BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(DPN_ID_2);
 413         BridgeInterfaceEntryKey bridgeInterfaceEntryKey = new BridgeInterfaceEntryKey(TUNNEL_INTERFACE_NAME);
 414         InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid = InterfaceMetaUtils
 415                 .getBridgeInterfaceEntryIdentifier(bridgeEntryKey, bridgeInterfaceEntryKey);
 416         // TODO Later use nicer abstraction for DB access here.. see
 417         // ElanServiceTest
 418         assertEqualBeans(InterfaceMeta.newBridgeInterface(),
 419                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION, bridgeInterfaceEntryIid).get());
 420
 421         // Then
 422         // a) check if termination end point is created in
 423         // config/network-topology
 424         final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.tbd.params
 425             .xml.ns.yang.network.topology.rev131021.network.topology.topology.Node> bridgeIid = OvsdbSouthboundTestUtil
 426                 .createInstanceIdentifier("192.168.56.101", 6640, "s2");
 427         InstanceIdentifier<TerminationPoint> tpIid = InterfaceManagerTestUtil.getTerminationPointId(bridgeIid,
 428                 TUNNEL_INTERFACE_NAME);
 429         assertEqualTerminationPoints(ExpectedTerminationPoint.newTerminationPoint(), db.syncRead(CONFIGURATION, tpIid));
 430
 431         // When termination end point is populated in network-topology
 432         OvsdbSouthboundTestUtil.createTerminationPoint(dataBroker, TUNNEL_INTERFACE_NAME, InterfaceTypeVxlan.class,
 433             null);
 434         InterfaceManagerTestUtil.createFlowCapableNodeConnector(dataBroker, TUNNEL_INTERFACE_NAME, Tunnel.class);
 435         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 436         Thread.sleep(3000);
 437         TestableQueues.awaitEmpty(batchingUtils.getQueue(DEFAULT_OPERATIONAL), 1, MINUTES);
 438
 439         // Then
 440         // a) check if operational/ietf-interfaces-state is populated for the tunnel interface
 441         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 442             .interfaces.state.Interface ifaceState =
 443             dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 444                 IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
 445         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
 446             TUNNEL_INTERFACE_NAME, Interface.OperStatus.Up, Tunnel.class, DPN_ID_2.toString(),
 447                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 448
 449         // Test all RPCs related to tunnel interfaces
 450         checkTunnelRpcs();
 451
 452         checkTunnelApis();
 453
 454         // Update test
 455         // i) Enable Tunnel Monitoring
 456         InterfaceManagerTestUtil.updateTunnelMonitoringAttributes(dataBroker, TUNNEL_INTERFACE_NAME);
 457         InterfaceManagerTestUtil.waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 458         // Then verify if bfd attributes are updated in topology config DS
 459         assertEqualTerminationPoints(ExpectedTerminationPoint.newBfdEnabledTerminationPoint(),
 460                 db.syncRead(CONFIGURATION, tpIid));
 461
 462         //state modification tests
 463         // 1. Make the operational state of port as DOWN
 464         InterfaceManagerTestUtil.updateFlowCapableNodeConnectorState(dataBroker, TUNNEL_INTERFACE_NAME, Tunnel
 465             .class, false);
 466         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 467
 468         ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 469             IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
 470         // Verify if operational/ietf-interface-state is still up
 471         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
 472             TUNNEL_INTERFACE_NAME, Interface.OperStatus.Up, Tunnel.class, DPN_ID_2.toString(),
 473                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 474
 475         // 2. Make BFD staus of tunnel port as down
 476         OvsdbSouthboundTestUtil.updateTerminationPoint(dataBroker, TUNNEL_INTERFACE_NAME, InterfaceTypeVxlan.class);
 477         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 478
 479         ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 480             IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
 481         // Verify if operational/ietf-interface-state is marked down
 482         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
 483             TUNNEL_INTERFACE_NAME, Interface.OperStatus.Down, Tunnel.class, DPN_ID_2.toString(),
 484                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 485
 486
 487         // 2. Delete the Node
 488         InterfaceManagerTestUtil.removeNode(dataBroker);
 489         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 490         ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 491             IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get().get();
 492         // Verify if operational/ietf-interface-state is marked unknown
 493         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(),
 494             TUNNEL_INTERFACE_NAME, Interface.OperStatus.Unknown, Tunnel.class, DPN_ID_2.toString(),
 495                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 496
 497         // Re-create port to proceed with further tests
 498         InterfaceManagerTestUtil.createFlowCapableNodeConnector(dataBroker, TUNNEL_INTERFACE_NAME, Tunnel.class);
 499         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 500
 501
 502         // 2. Delete the OF port
 503         InterfaceManagerTestUtil.removeFlowCapableNodeConnectorState(dataBroker, Tunnel.class);
 504         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 505
 506         // Verify if operational-states are deleted
 507         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 508             IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get());
 509         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 510             IfmUtil.buildStateInterfaceId(TUNNEL_INTERFACE_NAME)).get());
 511
 512         // Delete test
 513         // iii) tunnel interface is deleted from config/ietf-interfaces
 514         InterfaceManagerTestUtil.deleteInterfaceConfig(dataBroker, TUNNEL_INTERFACE_NAME);
 515         InterfaceManagerTestUtil.waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 516
 517         // Then
 518         // a) check if tunnel is deleted from bridge-interface-info
 519         Assert.assertEquals(Optional.empty(),
 520                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION, bridgeInterfaceEntryIid).get());
 521
 522         // b) check if termination end point is deleted in
 523         // config/network-topology
 524         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(CONFIGURATION, tpIid).get());
 525         waitTillOperationCompletes(coordinatorEventsWaiter, asyncEventsWaiter);
 526     }
 527
 528     private void assertEqualTerminationPoints(TerminationPoint expected, TerminationPoint actual) {
 529         // Re-create the termination points to avoid re-deserialising the augmentations
 530         assertEqualBeans(rebuildTerminationPoint(expected), rebuildTerminationPoint(actual));
 531     }
 532
 533     private TerminationPoint rebuildTerminationPoint(TerminationPoint tp) {
 534         // The problem we're fixing here is that, in MD-SAL binding v1, YANG lists are represented
 535         // as Java lists but they don't preserve order (unless they specify “ordered-by user”).
 536         // YANG keyed lists in particular are backed by maps, so you can store such a list in the
 537         // MD-SAL and get it back in a different order.
 538         // When comparing beans involving such lists, we need to sort the lists before comparing
 539         // them. Retrieving the augmentation gives a modifiable list, so it's tempting to just
 540         // sort that — but the list is re-created every time the augmentation is retrieved, so
 541         // the sort is lost.
 542         // To avoid all this, we rebuild instances of TerminationPoint, and sort the affected lists
 543         // in the augmentations, with full augmentation rebuilds too (since the lists in a built
 544         // augmentation might be unmodifiable).
 545         TerminationPointBuilder newTpBuilder = new TerminationPointBuilder(tp);
 546         OvsdbTerminationPointAugmentation ovsdbTpAugmentation =
 547                 tp.augmentation(OvsdbTerminationPointAugmentation.class);
 548         if (ovsdbTpAugmentation != null) {
 549             OvsdbTerminationPointAugmentationBuilder newOvsdbTpAugmentationBuilder =
 550                     new OvsdbTerminationPointAugmentationBuilder(ovsdbTpAugmentation);
 551             if (ovsdbTpAugmentation.getOptions() != null) {
 552                 List<Options> options = new ArrayList<>(ovsdbTpAugmentation.getOptions().values());
 553                 options.sort(Comparator.comparing(o -> o.key().toString()));
 554                 newOvsdbTpAugmentationBuilder.setOptions(options);
 555             }
 556             if (ovsdbTpAugmentation.getInterfaceBfd() != null) {
 557                 List<InterfaceBfd> interfaceBfd = new ArrayList<>(ovsdbTpAugmentation.getInterfaceBfd().values());
 558                 interfaceBfd.sort(Comparator.comparing(o -> o.key().toString()));
 559                 newOvsdbTpAugmentationBuilder.setInterfaceBfd(interfaceBfd);
 560             }
 561             newTpBuilder.addAugmentation(newOvsdbTpAugmentationBuilder.build());
 562         }
 563         return newTpBuilder.build();
 564     }
 565
 566     private void checkVlanApis() throws Exception {
 567         // 1. Test port-no corresponding to interface
 568         long portNo = interfaceManager.getPortForInterface(INTERFACE_NAME);
 569         Assert.assertEquals(PORT_NO_1, portNo);
 570
 571         // 2. fetch interface config from datastore API
 572         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
 573             interfaceInfo = interfaceManager.getInterfaceInfoFromConfigDataStore(INTERFACE_NAME);
 574         // FIXME change this once augmentation sorting fix lands
 575         assertEqualBeans(INTERFACE_NAME, interfaceInfo.getName());
 576         assertEqualBeans(PARENT_INTERFACE, interfaceInfo.augmentation(ParentRefs.class).getParentInterface());
 577
 578         // 3. fetch dpn-id corresponding to an interface
 579         Uint64 dpnId = interfaceManager.getDpnForInterface(INTERFACE_NAME);
 580         Assert.assertEquals(DPN_ID_1, dpnId);
 581
 582         // 4. fetch parent-interface corresponding to an interface
 583         Assert.assertEquals(PARENT_INTERFACE, interfaceManager.getParentRefNameForInterface(INTERFACE_NAME));
 584
 585         //5. get interface information
 586         assertEqualBeans(ExpectedInterfaceInfo.newVlanInterfaceInfo(), interfaceManager
 587             .getInterfaceInfo(INTERFACE_NAME));
 588
 589         Assert.assertEquals(org.opendaylight.genius.interfacemanager.globals.IfmConstants.VXLAN_GROUPID_MIN + 1,
 590             interfaceManager.getLogicalTunnelSelectGroupId(1));
 591
 592         // 6. Test bind ingress service
 593         BoundServices serviceInfo = InterfaceManagerTestUtil.buildServicesInfo("ELAN", NwConstants.ELAN_SERVICE_INDEX);
 594         interfaceManager.bindService(INTERFACE_NAME, ServiceModeIngress.class, serviceInfo);
 595
 596         waitTillOperationCompletes("test bind ingress service api",
 597                 coordinatorEventsWaiter, 1, asyncEventsWaiter);
 598
 599         String lportDispatcherFlowRef = String.valueOf(dpnId) + NwConstants.FLOWID_SEPARATOR
 600                 + NwConstants.LPORT_DISPATCHER_TABLE + NwConstants.FLOWID_SEPARATOR + INTERFACE_NAME
 601                 + NwConstants.FLOWID_SEPARATOR + NwConstants.DEFAULT_SERVICE_INDEX;
 602         FlowKey lportDispatcherFlowKey = new FlowKey(new FlowId(lportDispatcherFlowRef));
 603         Node nodeDpn = InterfaceManagerTestUtil.buildInventoryDpnNode(dpnId);
 604         InstanceIdentifier<Flow> lportDispatcherFlowId = InstanceIdentifier.builder(Nodes.class)
 605             .child(Node.class, nodeDpn.key()).augmentation(FlowCapableNode.class)
 606             .child(Table.class, new TableKey(NwConstants.LPORT_DISPATCHER_TABLE)).child(Flow.class,
 607                 lportDispatcherFlowKey).build();
 608         flowAssertTestUtils.assertFlowsInAnyOrder(ExpectedFlowEntries.newLportDispatcherFlow(),
 609                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION, lportDispatcherFlowId).get().get());
 610
 611         // check whether service-binding state cache is populated
 612         assertEqualBeans(ExpectedBoundServiceState.newBoundServiceState(), FlowBasedServicesUtils
 613             .getBoundServicesState(dataBroker.newReadOnlyTransaction(), INTERFACE_NAME, ServiceModeIngress.class));
 614
 615         //7. test check whether service is bound on ingress
 616         Assert.assertTrue(interfaceManager.isServiceBoundOnInterfaceForIngress(NwConstants.ELAN_SERVICE_INDEX,
 617             INTERFACE_NAME));
 618
 619         //8. test unbind ingress service
 620         interfaceManager.unbindService(INTERFACE_NAME, ServiceModeIngress.class, serviceInfo);
 621         waitTillOperationCompletes("test unbind ingress service api",
 622                 coordinatorEventsWaiter, 2, asyncEventsWaiter);
 623
 624         Assert.assertEquals(Optional.empty(),
 625             dataBroker.newReadOnlyTransaction().read(CONFIGURATION, lportDispatcherFlowId).get());
 626
 627         // check service-state cache is cleaned up
 628         // 9. Test bind egress service
 629         short egressACLIndex = ServiceIndex.getIndex(NwConstants.EGRESS_ACL_SERVICE_NAME,
 630             NwConstants.EGRESS_ACL_SERVICE_INDEX);
 631         serviceInfo = InterfaceManagerTestUtil.buildServicesInfo("EGRESS_ACL", egressACLIndex);
 632         interfaceManager.bindService(INTERFACE_NAME, ServiceModeEgress.class, serviceInfo);
 633         waitTillOperationCompletes("test bind egress service api",
 634                 coordinatorEventsWaiter, 1, asyncEventsWaiter);
 635
 636         String egressDispatcherFlowRef = String.valueOf(dpnId) + NwConstants.FLOWID_SEPARATOR
 637                 + NwConstants.EGRESS_LPORT_DISPATCHER_TABLE + NwConstants.FLOWID_SEPARATOR
 638                 + INTERFACE_NAME + NwConstants.FLOWID_SEPARATOR + NwConstants.DEFAULT_EGRESS_SERVICE_INDEX;
 639
 640         FlowKey egressDispatcherFlowKey = new FlowKey(new FlowId(egressDispatcherFlowRef));
 641         InstanceIdentifier<Flow> egressDispatcherFlowId = InstanceIdentifier.builder(Nodes.class)
 642             .child(Node.class, nodeDpn.key()).augmentation(FlowCapableNode.class)
 643             .child(Table.class, new TableKey(NwConstants.EGRESS_LPORT_DISPATCHER_TABLE)).child(Flow.class,
 644                 egressDispatcherFlowKey).build();
 645
 646         // FIXME the extend file getting generated had some import issues, will revist  later
 647         //assertEqualBeans(null,
 648         //    dataBroker.newReadOnlyTransaction().read(CONFIGURATION, egressDispatcherFlowId).get());
 649
 650         Assert.assertNotNull(dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
 651             egressDispatcherFlowId).get());
 652
 653         //10. test check whether service is bound on egress
 654         Assert.assertTrue(interfaceManager.isServiceBoundOnInterfaceForEgress(NwConstants.EGRESS_ACL_SERVICE_INDEX,
 655             INTERFACE_NAME));
 656
 657         // 11. Test unbinding of egress service
 658         interfaceManager.unbindService(INTERFACE_NAME, ServiceModeEgress.class, serviceInfo);
 659         waitTillOperationCompletes("test unbind egress service api",
 660                 coordinatorEventsWaiter, 2, asyncEventsWaiter);
 661         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(CONFIGURATION,
 662             egressDispatcherFlowId).get());
 663
 664         // 12. Test fetching child interfaces of an interface
 665         // FIXME change the below assert once sorted augmentation fix lands
 666         assertEqualBeans(INTERFACE_NAME, interfaceManager.getChildInterfaces(PARENT_INTERFACE).get(0).getName());
 667
 668         // 13. Test fetching interface-info from operational DS
 669         assertEqualBeans(ExpectedInterfaceInfo.newInterfaceInfo(1, INTERFACE_NAME, PARENT_INTERFACE, null),
 670             interfaceManager.getInterfaceInfoFromOperationalDataStore(INTERFACE_NAME));
 671
 672         // 14. Test fetching of interface-info from oper DS, given interface-type
 673         assertEqualBeans(ExpectedInterfaceInfo.newInterfaceInfo(1, INTERFACE_NAME, INTERFACE_NAME, InterfaceInfo
 674             .InterfaceType.VLAN_INTERFACE), interfaceManager.getInterfaceInfoFromOperationalDataStore(
 675                 INTERFACE_NAME, InterfaceInfo.InterfaceType.VLAN_INTERFACE));
 676
 677         // 15.Test fetching of interface-info from cache
 678         assertEqualBeans(ExpectedInterfaceInfo.newInterfaceInfo(1, INTERFACE_NAME, PARENT_INTERFACE, null),
 679             interfaceManager.getInterfaceInfoFromOperationalDSCache(INTERFACE_NAME));
 680
 681         // 16. Test creation of VLAN interface
 682         // FIXME Make IInterfaceManager truly async
 683         interfaceManager.createVLANInterface(INTERFACE_NAME_1, PARENT_INTERFACE_1, null, INTERFACE_NAME_1,
 684             IfL2vlan.L2vlanMode.Trunk);
 685         //waitTillOperationCompletes(coordinatorEventsWaiter, 1, asyncEventsWaiter);
 686
 687         //assertEqualBeans(ExpectedInterfaceConfig.newVlanInterfaceConfig(INTERFACE_NAME_1, null),
 688         //    dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil.buildId(
 689         //        INTERFACE_NAME_1)).get());
 690
 691         // 17. Update Parent Refs for VLAN interface
 692         // FIXME Make IInterfaceManager truly async
 693         //interfaceManager.updateInterfaceParentRef(INTERFACE_NAME_1, PARENT_INTERFACE_1);
 694         waitTillOperationCompletes("create vlan interface api",
 695                 coordinatorEventsWaiter, 4, asyncEventsWaiter);
 696
 697         assertEqualBeans(ExpectedInterfaceConfig.newVlanInterfaceConfig(INTERFACE_NAME_1, PARENT_INTERFACE_1),
 698             dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil
 699                 .buildId(INTERFACE_NAME_1)).get());
 700
 701         // 18. Test creation of external l2vlan interfaces
 702         // FIXME Make IInterfaceManager truly async
 703         interfaceManager.createVLANInterface(INTERFACE_NAME_2, PARENT_INTERFACE_2, null, INTERFACE_NAME_2,
 704             IfL2vlan.L2vlanMode.Trunk, true);
 705         //waitTillOperationCompletes(coordinatorEventsWaiter, 1, asyncEventsWaiter);
 706
 707         // FIXME need to wait for https://git.opendaylight.org/gerrit/#/c/54811/ this to land
 708         // to do proper assertion
 709         //Assert.assertNotNull(dataBroker
 710         //    .newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil
 711         //    .buildId(INTERFACE_NAME_2)).get().augmentation(IfExternal.class));
 712
 713         // 19. update parent-refs
 714         //interfaceManager.updateInterfaceParentRef(INTERFACE_NAME_2, PARENT_INTERFACE_2, true);
 715         waitTillOperationCompletes("create external vlan interface api",
 716                 coordinatorEventsWaiter, 4, asyncEventsWaiter);
 717         Assert.assertEquals(PARENT_INTERFACE_2, dataBroker
 718             .newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, IfmUtil
 719                 .buildId(INTERFACE_NAME_2)).get().get().augmentation(ParentRefs.class).getParentInterface());
 720
 721         // 20. get list of vlan interfaces
 722         // FIXME need to wait for https://git.opendaylight.org/gerrit/#/c/54811/ this to land
 723         // to do proper assertion
 724         assertEqualBeans(3, interfaceManager.getVlanInterfaces().size());
 725
 726         // 21. check if an interface is external interface
 727         Assert.assertTrue(interfaceManager.isExternalInterface(INTERFACE_NAME_2));
 728
 729         // 22. check port name for an interface, given dpn-id and interface-name
 730         assertEqualBeans(PARENT_INTERFACE, interfaceManager.getPortNameForInterface(DPN_ID_1.toString(),
 731             PARENT_INTERFACE));
 732
 733         // 23. check port name for an interface, given nodeconnectorid
 734         assertEqualBeans(PARENT_INTERFACE, interfaceManager.getPortNameForInterface(new NodeConnectorId("openflow:1:2"),
 735             PARENT_INTERFACE));
 736
 737         // 24. get termination-points from cache
 738         Assert.assertNotNull(interfaceManager.getTerminationPointCache().get(INTERFACE_NAME));
 739
 740         // 25. fetch termination point for interface
 741         assertEqualBeans(ExpectedTerminationPoint.newOvsdbTerminationPointAugmentation(), interfaceManager
 742             .getTerminationPointForInterface(INTERFACE_NAME));
 743
 744         // 26. fetch ovsdb bridge corresponding to an interface
 745         assertEqualBeans(ExpectedOvsdbBridge.newOvsdbBridge(),
 746             interfaceManager.getOvsdbBridgeForInterface(INTERFACE_NAME));
 747
 748         // 27. fetch ovsdb bridge corresponding to nodeIid
 749         assertEqualBeans(ExpectedOvsdbBridge.newOvsdbBridge(), interfaceManager.getOvsdbBridgeForNodeIid(
 750             OvsdbSouthboundTestUtil.createInstanceIdentifier("192.168.56.101", 6640, "s2")));
 751     }
 752
 753     private void checkVlanRpcs() throws Exception {
 754         //1. Test dpn-id fetching from interface
 755         GetDpidFromInterfaceInput dpidFromInterfaceInput = new GetDpidFromInterfaceInputBuilder()
 756                 .setIntfName(INTERFACE_NAME).build();
 757         Future<RpcResult<GetDpidFromInterfaceOutput>> dpidFromInterfaceOutput =
 758             odlInterfaceRpcService.getDpidFromInterface(dpidFromInterfaceInput);
 759         Assert.assertEquals(DpnFromInterfaceOutput.newDpnFromInterfaceOutput(),
 760                 dpidFromInterfaceOutput.get().getResult());
 761
 762         //3. Test egress actions fetching for interface
 763         GetEgressActionsForInterfaceInput egressActionsForInterfaceInput = new
 764             GetEgressActionsForInterfaceInputBuilder().setIntfName(INTERFACE_NAME).build();
 765         Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsForInterfaceOutput =
 766             odlInterfaceRpcService.getEgressActionsForInterface(egressActionsForInterfaceInput);
 767         assertEqualBeans(EgressActionsForInterfaceOutput.newEgressActionsForInterfaceOutput(),
 768             egressActionsForInterfaceOutput.get().getResult());
 769
 770         //4. Test egress instructions fetching for interface
 771         GetEgressInstructionsForInterfaceInput egressInstructionsForInterfaceInput = new
 772             GetEgressInstructionsForInterfaceInputBuilder().setIntfName(INTERFACE_NAME).build();
 773         Future<RpcResult<GetEgressInstructionsForInterfaceOutput>> egressInstructionsForInterfaceOutput =
 774             odlInterfaceRpcService.getEgressInstructionsForInterface(egressInstructionsForInterfaceInput);
 775         assertEqualBeans(EgressInstructionsForInterfaceOutput.newEgressInstructionsForInterfaceOutput(),
 776             egressInstructionsForInterfaceOutput.get().getResult());
 777
 778
 779         //5. Test interface fetching from if-index
 780         /* FIXME can be tested only once ResourceBatchingManager becomes testable
 781         GetInterfaceFromIfIndexInput interfaceFromIfIndexInput = new GetInterfaceFromIfIndexInputBuilder()
 782                 .setIfIndex(1).build();
 783         Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndexOutput = odlInterfaceRpcService
 784             .getInterfaceFromIfIndex(interfaceFromIfIndexInput);
 785         assertEqualBeans(InterfaceFromIfIndexOutput.newInterfaceFromIfIndexOutput(),
 786                 interfaceFromIfIndexOutput.get().getResult());*/
 787
 788         //6. Test interface type fetching from interface-name
 789         GetInterfaceTypeInput interfaceTypeInput = new GetInterfaceTypeInputBuilder().setIntfName(INTERFACE_NAME)
 790             .build();
 791         Future<RpcResult<GetInterfaceTypeOutput>> interfaceTypeOutput =
 792                 odlInterfaceRpcService.getInterfaceType(interfaceTypeInput);
 793         assertEqualBeans(InterfaceTypeOutput.newInterfaceTypeOutput(), interfaceTypeOutput.get().getResult());
 794
 795         //7. Test get nodeconnector-id from interface-name
 796         GetNodeconnectorIdFromInterfaceInput nodeconnectorIdFromInterfaceInput = new
 797             GetNodeconnectorIdFromInterfaceInputBuilder().setIntfName(INTERFACE_NAME).build();
 798         Future<RpcResult<GetNodeconnectorIdFromInterfaceOutput>> nodeconnectorIdFromInterfaceOutput =
 799             odlInterfaceRpcService.getNodeconnectorIdFromInterface(nodeconnectorIdFromInterfaceInput);
 800         assertEqualBeans(NodeconnectorIdFromInterfaceOutput.newNodeconnectorIdFromInterfaceOutput(),
 801             nodeconnectorIdFromInterfaceOutput.get().getResult());
 802
 803         //8. Test get port details from interface-name
 804         GetPortFromInterfaceInput portFromInterfaceInput =
 805                 new GetPortFromInterfaceInputBuilder().setIntfName(INTERFACE_NAME).build();
 806         Future<RpcResult<GetPortFromInterfaceOutput>> portFromInterfaceOutput = odlInterfaceRpcService
 807             .getPortFromInterface(portFromInterfaceInput);
 808         assertEqualBeans(PortFromInterfaceOutput.newPortFromInterfaceOutput(),
 809                 portFromInterfaceOutput.get().getResult());
 810     }
 811
 812     private void checkTunnelRpcs() throws Exception {
 813         //1. Test endpoint ip fetching for dpn-id
 814         GetEndpointIpForDpnInput endpointIpForDpnInput = new GetEndpointIpForDpnInputBuilder().setDpid(DPN_ID_2)
 815             .build();
 816         Future<RpcResult<GetEndpointIpForDpnOutput>> endpointIpForDpnOutput = odlInterfaceRpcService
 817                 .getEndpointIpForDpn(endpointIpForDpnInput);
 818         assertEqualBeans(EndPointIpFromDpn.newEndPointIpFromDpn(), endpointIpForDpnOutput.get().getResult());
 819
 820
 821         //2. fetch tunnel type from interface-name
 822         GetTunnelTypeInput tunnelTypeInput = new GetTunnelTypeInputBuilder().setIntfName(TUNNEL_INTERFACE_NAME).build();
 823         Future<RpcResult<GetTunnelTypeOutput>> tunnelTypeOutput = odlInterfaceRpcService.getTunnelType(tunnelTypeInput);
 824         assertEqualBeans(TunnelTypeOutput.newTunnelTypeOutput(), tunnelTypeOutput.get().getResult());
 825     }
 826
 827     private void checkTunnelApis() throws  Exception {
 828
 829         // 1. fetch get all ports on bridge
 830         assertEqualBeans(ExpectedTerminationPoint.newTerminationPointList(),
 831             interfaceManager.getPortsOnBridge(DPN_ID_2));
 832
 833         // 2. fetch get all tunnel ports on bridge
 834         assertEqualBeans(ExpectedTerminationPoint.newTerminationPointList(),
 835             interfaceManager.getTunnelPortsOnBridge(DPN_ID_2));
 836
 837         // 3. fetch tunnel end point ip for DPN
 838         assertEqualBeans("2.2.2.2", interfaceManager.getEndpointIpForDpn(DPN_ID_2));
 839
 840         // 4. get list of vxlan interfaces
 841         assertEqualBeans(1, interfaceManager.getVxlanInterfaces().size());
 842     }
 843
 844     public void testVlanMemberInterface() throws Exception {
 845         // Test VlanMember interface creation
 846         InterfaceManagerTestUtil.putVlanInterfaceConfig(dataBroker, TRUNK_INTERFACE_NAME, INTERFACE_NAME,
 847                 IfL2vlan.L2vlanMode.TrunkMember);
 848         InterfaceManagerTestUtil.waitTillOperationCompletes("create vlan member interface",
 849                 coordinatorEventsWaiter, 7, asyncEventsWaiter);
 850
 851         // 3. Then
 852         // a) check expected interface-child entry mapping in odl-interface-meta/config/interface-child-info was created
 853         InstanceIdentifier<InterfaceChildEntry> interfaceChildEntryInstanceIdentifier = InterfaceMetaUtils
 854             .getInterfaceChildEntryIdentifier(new InterfaceParentEntryKey(INTERFACE_NAME),
 855                 new InterfaceChildEntryKey(TRUNK_INTERFACE_NAME));
 856         assertEqualBeans(ExpectedInterfaceChildEntry.interfaceChildEntry(TRUNK_INTERFACE_NAME),
 857                 dataBroker.newReadOnlyTransaction().read(CONFIGURATION, interfaceChildEntryInstanceIdentifier)
 858                         .get());
 859
 860         // Then
 861         // a) check if operational/ietf-interfaces-state is populated for the vlan interface
 862         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 863             .interfaces.state.Interface ifaceState =
 864             dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 865                 IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).get().get();
 866         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(), TRUNK_INTERFACE_NAME,
 867                 Interface.OperStatus.Up, L2vlan.class, DPN_ID_1.toString(),
 868                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 869
 870         // FIXME can assert this only once ResourceBatchingManager becomes testable
 871         // b) check if lport-tag to interface mapping is created
 872         /*InstanceIdentifier<IfIndexInterface> ifIndexInterfaceInstanceIdentifier = InstanceIdentifier.builder(
 873             IfIndexesInterfaceMap.class).child(
 874             IfIndexInterface.class, new IfIndexInterfaceKey(ifaceState.getIfIndex())).build();
 875         Assert.assertEquals(TRUNK_INTERFACE_NAME, dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 876             ifIndexInterfaceInstanceIdentifier).get().getInterfaceName());*/
 877
 878         //Update test
 879         // i) vlan member interface admin-state updated
 880         InterfaceManagerTestUtil.updateInterfaceAdminState(dataBroker, TRUNK_INTERFACE_NAME, false);
 881
 882         InterfaceManagerTestUtil.waitTillOperationCompletes("update vlan member interface admin state",
 883                 coordinatorEventsWaiter, 2, asyncEventsWaiter);
 884
 885         //Then
 886         // a) check if operational/ietf-interfaces-state is updated for vlan interface
 887         ifaceState = dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 888             IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).get().get();
 889         assertEqualBeans(ExpectedInterfaceState.newInterfaceState(ifaceState.getIfIndex(), TRUNK_INTERFACE_NAME,
 890             Interface.OperStatus.Down, L2vlan.class, DPN_ID_1.toString(),
 891                 ifaceState.getStatistics().getDiscontinuityTime()), ifaceState);
 892
 893         InterfaceManagerTestUtil.deleteInterfaceConfig(dataBroker, TRUNK_INTERFACE_NAME);
 894         InterfaceManagerTestUtil.waitTillOperationCompletes("delete vlan member interface",
 895                 coordinatorEventsWaiter, 7, asyncEventsWaiter);
 896         // 1. Then
 897         // a)
 898         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction()
 899             .read(CONFIGURATION, interfaceChildEntryInstanceIdentifier).get());
 900
 901         // b) check if operational/ietf-interfaces-state is deleted for the vlan interface
 902         Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 903             IfmUtil.buildStateInterfaceId(TRUNK_INTERFACE_NAME)).get());
 904
 905         // FIXME can assert this only once ResourceBatchingManager becomes testable
 906         // c) check if lport-tag to interface mapping is deleted
 907         /*Assert.assertEquals(Optional.empty(), dataBroker.newReadOnlyTransaction().read(OPERATIONAL,
 908             ifIndexInterfaceInstanceIdentifier).get());*/
 909     }
 910
 911     @Ignore
 912     @Test
 913     public void testDpnToInterfaceList() throws  Exception {
 914         //Write into DpnToInterfaceList
 915         createDpnToInterface(DPN_ID_1, "23701c04-7e58-4c65-9425-78a80d49a218", L2vlan.class);
 916
 917         //Test interface list fetching from dpnId
 918         GetDpnInterfaceListInput dpnInterfaceListInput = new GetDpnInterfaceListInputBuilder()
 919                 .setDpid(DPN_ID_1).build();
 920         Future<RpcResult<GetDpnInterfaceListOutput>> dpnInterfaceListOutput = odlInterfaceRpcService
 921                 .getDpnInterfaceList(dpnInterfaceListInput);
 922
 923         List<Interfaces> actualDpnInterfaceList = dpnInterfaceListOutput.get().getResult().getInterfaces();
 924         assertEqualBeans(ExpectedInterfaceListFromDpn.checkDpnToInterfaceList(), actualDpnInterfaceList.get(0));
 925     }
 926
 927     private void createDpnToInterface(Uint64 dpId, String infName,
 928                                       Class<? extends InterfaceType> interfaceType) throws  Exception {
 929         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 930         DpnToInterfaceKey dpnToInterfaceKey = new DpnToInterfaceKey(dpId);
 931         InterfaceNameEntryKey interfaceNameEntryKey = new InterfaceNameEntryKey(infName);
 932         InstanceIdentifier<InterfaceNameEntry> intfid = InstanceIdentifier.builder(DpnToInterfaceList.class)
 933                 .child(DpnToInterface.class, dpnToInterfaceKey)
 934                 .child(InterfaceNameEntry.class, interfaceNameEntryKey)
 935                 .build();
 936         InterfaceNameEntryBuilder entryBuilder =
 937                 new InterfaceNameEntryBuilder().withKey(interfaceNameEntryKey).setInterfaceName(infName);
 938         if (interfaceType != null) {
 939             entryBuilder.setInterfaceType(interfaceType);
 940         }
 941         tx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, intfid, entryBuilder.build());
 942         tx.commit().get();
 943     }
 944 }