southbound/southbound-it/src/test/java/org/opendaylight/ovsdb/southbound/it/SouthboundIT.java

   1 /*
   2  * Copyright (c) 2015 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.ovsdb.southbound.it;
   9
  10 import static org.junit.Assert.assertNotNull;
  11 import static org.junit.Assert.fail;
  12 import static org.ops4j.pax.exam.CoreOptions.maven;
  13 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
  14 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.features;
  15
  16 import com.google.common.collect.ImmutableBiMap;
  17 import com.google.common.collect.Lists;
  18 import com.google.common.collect.ObjectArrays;
  19
  20 import java.net.InetAddress;
  21 import java.net.UnknownHostException;
  22 import java.util.ArrayList;
  23 import java.util.HashSet;
  24 import java.util.List;
  25 import java.util.Properties;
  26 import java.util.Set;
  27
  28 import javax.inject.Inject;
  29
  30 import org.junit.Assert;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  35 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  36 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  37 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  38 import org.opendaylight.ovsdb.southbound.SouthboundProvider;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeBase;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntry;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  75 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  78 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  79 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  84 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  85 import org.ops4j.pax.exam.Configuration;
  86 import org.ops4j.pax.exam.Option;
  87 import org.ops4j.pax.exam.junit.PaxExam;
  88 import org.ops4j.pax.exam.karaf.options.LogLevelOption;
  89 import org.ops4j.pax.exam.options.MavenUrlReference;
  90 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
  91 import org.ops4j.pax.exam.spi.reactors.PerClass;
  92 import org.osgi.framework.Bundle;
  93 import org.osgi.framework.BundleContext;
  94 import org.slf4j.Logger;
  95 import org.slf4j.LoggerFactory;
  96
  97 /**
  98  * Integration tests for southbound-impl
  99  *
 100  * @author Sam Hague (shague@redhat.com)
 101  */
 102 @RunWith(PaxExam.class)
 103 @ExamReactorStrategy(PerClass.class)
 104 public class SouthboundIT extends AbstractMdsalTestBase {
 105     private static final String NETDEV_DP_TYPE = "netdev";
 106     private static final Logger LOG = LoggerFactory.getLogger(SouthboundIT.class);
 107     private static final int OVSDB_UPDATE_TIMEOUT = 1000;
 108     private static DataBroker dataBroker = null;
 109     private static String addressStr;
 110     private static String portStr;
 111     private static String connectionType;
 112     private static String extrasStr;
 113     private static Boolean setup = false;
 114     private static MdsalUtils mdsalUtils = null;
 115     //private static String extras = "false";
 116     private static final String NETVIRT = "org.opendaylight.ovsdb.openstack.net-virt";
 117     private static final String NETVIRTPROVIDERS = "org.opendaylight.ovsdb.openstack.net-virt-providers";
 118
 119     @Inject
 120     private BundleContext bundleContext;
 121
 122     @Configuration
 123     public Option[] config() {
 124         return super.config();
 125     }
 126
 127     @Override
 128     public String getModuleName() {
 129         return "southbound-impl";
 130     }
 131
 132     @Override
 133     public String getInstanceName() {
 134         return "southbound-default";
 135     }
 136
 137     @Override
 138     public MavenUrlReference getFeatureRepo() {
 139         return maven()
 140                 .groupId("org.opendaylight.ovsdb")
 141                 .artifactId("southbound-features")
 142                 .classifier("features")
 143                 .type("xml")
 144                 .versionAsInProject();
 145     }
 146
 147     @Override
 148     public String getFeatureName() {
 149         //setExtras();
 150         return "odl-ovsdb-southbound-impl-ui";
 151     }
 152
 153     protected String usage() {
 154         return "Integration Test needs a valid connection configuration as follows :\n"
 155                 + "active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify\n"
 156                 + "passive connection : mvn -Dovsdbserver.connection=passive verify\n";
 157     }
 158
 159     @Override
 160     public Option[] getFeaturesOptions(final boolean extras) {
 161         if (extras == true) {
 162             Option[] options = new Option[] {
 163                     features("mvn:org.opendaylight.ovsdb/features-ovsdb/1.1.0-SNAPSHOT/xml/features",
 164                             "odl-ovsdb-openstack-sb")};
 165             return options;
 166         } else {
 167             return new Option[]{};
 168         }
 169     }
 170
 171     @Override
 172     public Option[] getLoggingOptions(final boolean extras) {
 173         Option[] options = new Option[] {
 174                 /*editConfigurationFilePut(SouthboundITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 175                         "log4j.logger.org.opendaylight.ovsdb",
 176                         LogLevelOption.LogLevel.DEBUG.name()),*/
 177                 editConfigurationFilePut(SouthboundITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 178                         "log4j.logger.org.opendaylight.ovsdb.southbound-impl",
 179                         LogLevelOption.LogLevel.DEBUG.name())
 180         };
 181
 182         if (extras == true) {
 183             Option[] extraOptions = new Option[] {
 184                 editConfigurationFilePut(SouthboundITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 185                         "log4j.logger.org.opendaylight.ovsdb",
 186                         LogLevelOption.LogLevel.DEBUG.name()),
 187                 editConfigurationFilePut(SouthboundITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 188                         "log4j.logger.org.opendaylight.ovsdb.openstack.net-virt",
 189                         LogLevelOption.LogLevel.DEBUG.name())
 190             };
 191             options = ObjectArrays.concat(options, extraOptions, Option.class);
 192         }
 193
 194         options = ObjectArrays.concat(options, super.getLoggingOptions(extras), Option.class);
 195         return options;
 196     }
 197
 198     @Override
 199     public Option[] getPropertiesOptions(final boolean extras) {
 200         Properties props = new Properties(System.getProperties());
 201         String addressStr = props.getProperty(SouthboundITConstants.SERVER_IPADDRESS,
 202                 SouthboundITConstants.DEFAULT_SERVER_IPADDRESS);
 203         String portStr = props.getProperty(SouthboundITConstants.SERVER_PORT,
 204                 SouthboundITConstants.DEFAULT_SERVER_PORT);
 205         String connectionType = props.getProperty(SouthboundITConstants.CONNECTION_TYPE,
 206                 SouthboundITConstants.CONNECTION_TYPE_ACTIVE);
 207         String extrasStr = props.getProperty(SouthboundITConstants.SERVER_EXTRAS,
 208                 SouthboundITConstants.DEFAULT_SERVER_EXTRAS);
 209
 210         LOG.info("getPropertiesOptions: Using the following properties: mode= {}, ip:port= {}:{}, extras= {}",
 211                 connectionType, addressStr, portStr, extrasStr);
 212
 213         Option[] options = new Option[] {
 214                 editConfigurationFilePut(SouthboundITConstants.CUSTOM_PROPERTIES,
 215                         SouthboundITConstants.SERVER_IPADDRESS, addressStr),
 216                 editConfigurationFilePut(SouthboundITConstants.CUSTOM_PROPERTIES,
 217                         SouthboundITConstants.SERVER_PORT, portStr),
 218                 editConfigurationFilePut(SouthboundITConstants.CUSTOM_PROPERTIES,
 219                         SouthboundITConstants.CONNECTION_TYPE, connectionType),
 220                 editConfigurationFilePut(SouthboundITConstants.CUSTOM_PROPERTIES,
 221                         SouthboundITConstants.SERVER_EXTRAS, extrasStr)
 222         };
 223         return options;
 224     }
 225
 226
 227     public boolean setExtras() {
 228         Properties props = new Properties(System.getProperties());
 229         boolean extras = props.getProperty(SouthboundITConstants.SERVER_EXTRAS,
 230                 SouthboundITConstants.DEFAULT_SERVER_EXTRAS).equals("true");
 231         LOG.info("setExtras: {}", extras);
 232         return extras;
 233     }
 234
 235     @Before
 236     public void setUp() throws InterruptedException {
 237         if (setup == true) {
 238             LOG.info("Skipping setUp, already initialized");
 239             return;
 240         }
 241
 242         try {
 243             super.setup();
 244         } catch (Exception e) {
 245             e.printStackTrace();
 246         }
 247         //dataBroker = getSession().getSALService(DataBroker.class);
 248         Thread.sleep(3000);
 249         dataBroker = SouthboundProvider.getDb();
 250         Assert.assertNotNull("db should not be null", dataBroker);
 251
 252         addressStr = bundleContext.getProperty(SouthboundITConstants.SERVER_IPADDRESS);
 253         portStr = bundleContext.getProperty(SouthboundITConstants.SERVER_PORT);
 254         connectionType = bundleContext.getProperty(SouthboundITConstants.CONNECTION_TYPE);
 255         extrasStr = bundleContext.getProperty(SouthboundITConstants.SERVER_EXTRAS);
 256
 257         LOG.info("setUp: Using the following properties: mode= {}, ip:port= {}:{}, extras= {}",
 258                 connectionType, addressStr, portStr, extrasStr);
 259         if (connectionType.equalsIgnoreCase(SouthboundITConstants.CONNECTION_TYPE_ACTIVE)) {
 260             if (addressStr == null) {
 261                 fail(usage());
 262             }
 263         }
 264
 265         mdsalUtils = new MdsalUtils(dataBroker);
 266         setup = true;
 267
 268         if (extrasStr.equals("true")) {
 269             isBundleReady(bundleContext, NETVIRT);
 270             isBundleReady(bundleContext, NETVIRTPROVIDERS);
 271         }
 272     }
 273
 274     /**
 275      * Test passive connection mode. The southbound starts in a listening mode waiting for connections on port
 276      * 6640. This test will wait for incoming connections for {@link SouthboundITConstants.CONNECTION_INIT_TIMEOUT} ms.
 277      *
 278      * @throws InterruptedException
 279      */
 280     @Test
 281     public void testPassiveNode() throws InterruptedException {
 282         if (connectionType.equalsIgnoreCase(SouthboundITConstants.CONNECTION_TYPE_PASSIVE)) {
 283             //Wait for CONNECTION_INIT_TIMEOUT for the Passive connection to be initiated by the ovsdb-server.
 284             Thread.sleep(SouthboundITConstants.CONNECTION_INIT_TIMEOUT);
 285         }
 286     }
 287
 288     private ConnectionInfo getConnectionInfo(final String addressStr, final String portStr) {
 289         InetAddress inetAddress = null;
 290         try {
 291             inetAddress = InetAddress.getByName(addressStr);
 292         } catch (UnknownHostException e) {
 293             fail("Could not allocate InetAddress: " + e);
 294         }
 295
 296         IpAddress address = SouthboundMapper.createIpAddress(inetAddress);
 297         PortNumber port = new PortNumber(Integer.parseInt(portStr));
 298
 299         LOG.info("connectionInfo: {}", new ConnectionInfoBuilder()
 300                 .setRemoteIp(address)
 301                 .setRemotePort(port)
 302                 .build());
 303         return new ConnectionInfoBuilder()
 304                        .setRemoteIp(address)
 305                        .setRemotePort(port)
 306                        .build();
 307     }
 308
 309     private String connectionInfoToString(final ConnectionInfo connectionInfo) {
 310         return new String(connectionInfo.getRemoteIp().getValue()) + ":" + connectionInfo.getRemotePort().getValue();
 311     }
 312
 313     @Test
 314     public void testNetworkTopology() throws InterruptedException {
 315         NetworkTopology networkTopology = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION,
 316                 InstanceIdentifier.create(NetworkTopology.class));
 317         Assert.assertNotNull("NetworkTopology could not be found in " + LogicalDatastoreType.CONFIGURATION,
 318                 networkTopology);
 319
 320         networkTopology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
 321                 InstanceIdentifier.create(NetworkTopology.class));
 322         Assert.assertNotNull("NetworkTopology could not be found in " + LogicalDatastoreType.OPERATIONAL,
 323                 networkTopology);
 324     }
 325
 326     @Test
 327     public void testOvsdbTopology() throws InterruptedException {
 328         InstanceIdentifier<Topology> path = InstanceIdentifier
 329                 .create(NetworkTopology.class)
 330                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
 331
 332         Topology topology = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, path);
 333         Assert.assertNotNull("Topology could not be found in " + LogicalDatastoreType.CONFIGURATION,
 334                 topology);
 335
 336         topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, path);
 337
 338         Assert.assertNotNull("Topology could not be found in " + LogicalDatastoreType.OPERATIONAL,
 339                 topology);
 340     }
 341
 342     private boolean addOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
 343         boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
 344                 SouthboundMapper.createInstanceIdentifier(connectionInfo),
 345                 SouthboundMapper.createNode(connectionInfo));
 346         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 347         return result;
 348     }
 349
 350     private Node getOvsdbNode(final ConnectionInfo connectionInfo) {
 351         Node node = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
 352                 SouthboundMapper.createInstanceIdentifier(connectionInfo));
 353         return node;
 354     }
 355
 356     private boolean deleteOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
 357         boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 358                 SouthboundMapper.createInstanceIdentifier(connectionInfo));
 359         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 360         return result;
 361     }
 362
 363     private Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
 364         Assert.assertTrue(addOvsdbNode(connectionInfo));
 365         Node node = getOvsdbNode(connectionInfo);
 366         Assert.assertNotNull(node);
 367         LOG.info("Connected to {}", connectionInfoToString(connectionInfo));
 368         return node;
 369     }
 370
 371     private boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
 372         Assert.assertTrue(deleteOvsdbNode(connectionInfo));
 373         Node node = getOvsdbNode(connectionInfo);
 374         Assert.assertNull(node);
 375         //Assume.assumeNotNull(node); // Using assumeNotNull because there is no assumeNull
 376         LOG.info("Disconnected from {}", connectionInfoToString(connectionInfo));
 377         return true;
 378     }
 379
 380     @Test
 381     public void testAddDeleteOvsdbNode() throws InterruptedException {
 382         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 383         Node ovsdbNode = connectOvsdbNode(connectionInfo);
 384         Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
 385         //Assume.assumeTrue(disconnectOvsdbNode(connectionInfo));
 386     }
 387
 388     @Test
 389     public void testDpdkSwitch() throws InterruptedException {
 390         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 391         Node ovsdbNode = connectOvsdbNode(connectionInfo);
 392         List<DatapathTypeEntry> datapathTypeEntries = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)
 393                 .getDatapathTypeEntry();
 394         if (datapathTypeEntries == null) {
 395             LOG.info("DPDK not supported on this node.");
 396         } else {
 397             Class<? extends DatapathTypeBase> dpType = null;
 398             String dpTypeStr = null;
 399             for (DatapathTypeEntry dpTypeEntry : datapathTypeEntries) {
 400                 dpType = dpTypeEntry.getDatapathType();
 401                 dpTypeStr = SouthboundConstants.DATAPATH_TYPE_MAP.get(dpType);
 402                 LOG.info("dp type is {}", dpTypeStr);
 403                 if (dpTypeStr.equals(NETDEV_DP_TYPE)) {
 404                     LOG.info("Found a DPDK node; adding a corresponding netdev device");
 405                     InstanceIdentifier<Node> bridgeIid = SouthboundMapper.createInstanceIdentifier(connectionInfo,
 406                             new OvsdbBridgeName(SouthboundITConstants.BRIDGE_NAME));
 407                     NodeId bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
 408                     addBridge(connectionInfo, bridgeIid, SouthboundITConstants.BRIDGE_NAME, bridgeNodeId, false, null,
 409                             true, dpType);
 410
 411                     // Verify that the device is netdev
 412                     OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 413                     Assert.assertNotNull(bridge);
 414                     Assert.assertEquals(dpType, bridge.getDatapathType());
 415
 416                     // Add dpdk port
 417                     final String TEST_PORT_NAME = "testDPDKPort";
 418                     OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 419                             createGenericDpdkOvsdbTerminationPointAugmentationBuilder(TEST_PORT_NAME);
 420                     Assert.assertTrue(addTerminationPoint(bridgeNodeId, TEST_PORT_NAME, ovsdbTerminationBuilder));
 421
 422                     // Verify that DPDK port was created
 423                     InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 424                     Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
 425                             terminationPointIid);
 426                     Assert.assertNotNull(terminationPointNode);
 427
 428                     // Verify that each termination point has DPDK ifType
 429                     Class<? extends InterfaceTypeBase> dpdkIfType = SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP
 430                             .get("dpdk");
 431                     Class<? extends InterfaceTypeBase> opPort = null;
 432                     List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 433                     for (TerminationPoint terminationPoint : terminationPoints) {
 434                         OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation = terminationPoint
 435                                 .getAugmentation(OvsdbTerminationPointAugmentation.class);
 436                         if (ovsdbTerminationPointAugmentation.getName().equals(TEST_PORT_NAME)) {
 437                             opPort = ovsdbTerminationPointAugmentation
 438                                     .getInterfaceType();
 439                             Assert.assertEquals(dpdkIfType, opPort);
 440                         }
 441                     }
 442                     Assert.assertTrue(deleteBridge(connectionInfo));
 443                     break;
 444                 }
 445             }
 446         }
 447         Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
 448     }
 449
 450     @Test
 451     public void testOvsdbNodeOvsVersion() throws InterruptedException {
 452         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 453         Node ovsdbNode = connectOvsdbNode(connectionInfo);
 454         OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
 455         Assert.assertNotNull(ovsdbNodeAugmentation);
 456         assertNotNull(ovsdbNodeAugmentation.getOvsVersion());
 457         Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
 458         //Assume.assumeTrue(disconnectOvsdbNode(connectionInfo));
 459     }
 460
 461     @Test
 462     public void testOpenVSwitchOtherConfig() throws InterruptedException {
 463         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 464         Node ovsdbNode = connectOvsdbNode(connectionInfo);
 465         OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
 466         Assert.assertNotNull(ovsdbNodeAugmentation);
 467         List<OpenvswitchOtherConfigs> otherConfigsList = ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
 468         if (otherConfigsList != null) {
 469             for (OpenvswitchOtherConfigs otherConfig : otherConfigsList) {
 470                 if (otherConfig.getOtherConfigKey().equals("local_ip")) {
 471                     LOG.info("local_ip: {}", otherConfig.getOtherConfigValue());
 472                     break;
 473                 } else {
 474                     LOG.info("other_config {}:{}", otherConfig.getOtherConfigKey(), otherConfig.getOtherConfigValue());
 475                 }
 476             }
 477         } else {
 478             LOG.info("other_config is not present");
 479         }
 480         Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
 481         //Assume.assumeTrue(disconnectOvsdbNode(connectionInfo));
 482     }
 483
 484     private void setManagedBy(final OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
 485                               final ConnectionInfo connectionInfo) {
 486         InstanceIdentifier<Node> connectionNodePath = SouthboundMapper.createInstanceIdentifier(connectionInfo);
 487         ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
 488     }
 489
 490     private List<ProtocolEntry> createMdsalProtocols() {
 491         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 492         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 493                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 494         protocolList.add(new ProtocolEntryBuilder().
 495                 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
 496         return protocolList;
 497     }
 498
 499     private OvsdbTerminationPointAugmentationBuilder createGenericOvsdbTerminationPointAugmentationBuilder() {
 500         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointAugmentationBuilder =
 501                 new OvsdbTerminationPointAugmentationBuilder();
 502         ovsdbTerminationPointAugmentationBuilder.setInterfaceType(
 503                 new InterfaceTypeEntryBuilder()
 504                         .setInterfaceType(
 505                                 SouthboundMapper.createInterfaceType("internal"))
 506                         .build().getInterfaceType());
 507         return ovsdbTerminationPointAugmentationBuilder;
 508     }
 509
 510     private OvsdbTerminationPointAugmentationBuilder createGenericDpdkOvsdbTerminationPointAugmentationBuilder(
 511             final String portName) {
 512         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 513                 createGenericOvsdbTerminationPointAugmentationBuilder();
 514         ovsdbTerminationBuilder.setName(portName);
 515         Class<? extends InterfaceTypeBase> ifType = SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP
 516                 .get("dpdk");
 517         ovsdbTerminationBuilder.setInterfaceType(ifType);
 518         return ovsdbTerminationBuilder;
 519     }
 520
 521     private boolean addTerminationPoint(final NodeId bridgeNodeId, final String portName,
 522             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointAugmentationBuilder)
 523         throws InterruptedException {
 524
 525         InstanceIdentifier<Node> portIid = SouthboundMapper.createInstanceIdentifier(bridgeNodeId);
 526         NodeBuilder portNodeBuilder = new NodeBuilder();
 527         NodeId portNodeId = SouthboundMapper.createManagedNodeId(portIid);
 528         portNodeBuilder.setNodeId(portNodeId);
 529         TerminationPointBuilder entry = new TerminationPointBuilder();
 530         entry.setKey(new TerminationPointKey(new TpId(portName)));
 531         entry.addAugmentation(
 532                 OvsdbTerminationPointAugmentation.class,
 533                 ovsdbTerminationPointAugmentationBuilder.build());
 534         portNodeBuilder.setTerminationPoint(Lists.newArrayList(entry.build()));
 535         boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
 536                 portIid, portNodeBuilder.build());
 537         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 538         return result;
 539     }
 540
 541     /*
 542      * base method for adding test bridges.  Other helper methods used to create bridges should utilize this method.
 543      *
 544      * @param connectionInfo
 545      * @param bridgeIid if passed null, one is created
 546      * @param bridgeName cannot be null
 547      * @param bridgeNodeId if passed null, one is created based on <code>bridgeIid</code>
 548      * @param setProtocolEntries toggles whether default protocol entries are set for the bridge
 549      * @param failMode toggles whether default fail mode is set for the bridge
 550      * @param setManagedBy toggles whether to setManagedBy for the bridge
 551      * @param dpType if passed null, this parameter is ignored
 552      * @return success of bridge addition
 553      * @throws InterruptedException
 554      */
 555     private boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
 556             final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
 557             final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
 558             final Class<? extends DatapathTypeBase> dpType) throws InterruptedException {
 559
 560         NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 561         if (bridgeIid == null) {
 562             bridgeIid = SouthboundMapper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 563         }
 564         if (bridgeNodeId == null) {
 565             bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
 566         }
 567         bridgeNodeBuilder.setNodeId(bridgeNodeId);
 568         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 569         ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 570         if (setProtocolEntries) {
 571             ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
 572         }
 573         if (failMode != null) {
 574             ovsdbBridgeAugmentationBuilder.setFailMode(failMode);
 575         }
 576         if (setManagedBy) {
 577             setManagedBy(ovsdbBridgeAugmentationBuilder, connectionInfo);
 578         }
 579         if (dpType != null) {
 580             ovsdbBridgeAugmentationBuilder.setDatapathType(dpType);
 581         }
 582         bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 583         LOG.debug("Built with the intent to store bridge data {}",
 584                 ovsdbBridgeAugmentationBuilder.toString());
 585         boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
 586                 bridgeIid, bridgeNodeBuilder.build());
 587         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 588         return result;
 589     }
 590
 591     private boolean addBridge(final ConnectionInfo connectionInfo, final String bridgeName)
 592         throws InterruptedException {
 593
 594         return addBridge(connectionInfo, null, bridgeName, null, true,
 595                 SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get("secure"), true, null);
 596     }
 597
 598     private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo) {
 599         InstanceIdentifier<Node> bridgeIid =
 600                 SouthboundMapper.createInstanceIdentifier(connectionInfo,
 601                         new OvsdbBridgeName(SouthboundITConstants.BRIDGE_NAME));
 602         Node bridgeNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
 603         Assert.assertNotNull(bridgeNode);
 604         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 605         Assert.assertNotNull(ovsdbBridgeAugmentation);
 606         return ovsdbBridgeAugmentation;
 607     }
 608
 609     private boolean deleteBridge(ConnectionInfo connectionInfo) throws InterruptedException {
 610         boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 611                 SouthboundMapper.createInstanceIdentifier(connectionInfo,
 612                         new OvsdbBridgeName(SouthboundITConstants.BRIDGE_NAME)));
 613         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 614         return result;
 615     }
 616
 617     @Test
 618     public void testAddDeleteBridge() throws InterruptedException {
 619         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 620         Node ovsdbNode = connectOvsdbNode(connectionInfo);
 621
 622         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 623         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 624         Assert.assertNotNull(bridge);
 625         LOG.info("bridge: {}", bridge);
 626
 627         Assert.assertTrue(deleteBridge(connectionInfo));
 628
 629         Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
 630         //Assume.assumeTrue(disconnectOvsdbNode(connectionInfo));
 631     }
 632
 633     private InstanceIdentifier<Node> getTpIid(ConnectionInfo connectionInfo, OvsdbBridgeAugmentation bridge) {
 634         return SouthboundMapper.createInstanceIdentifier(connectionInfo,
 635             bridge.getBridgeName());
 636     }
 637
 638     @Test
 639     public void testTerminationPointOfPort() throws InterruptedException {
 640         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 641         connectOvsdbNode(connectionInfo);
 642
 643         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 644         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 645         Assert.assertNotNull(bridge);
 646         LOG.info("bridge: {}", bridge);
 647         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 648                 connectionInfo, bridge.getBridgeName()));
 649         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 650                 createGenericOvsdbTerminationPointAugmentationBuilder();
 651         String portName = "testOfPort";
 652         ovsdbTerminationBuilder.setName(portName);
 653         Long ofPortExpected = new Long(45002);
 654         ovsdbTerminationBuilder.setOfport(ofPortExpected);
 655         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 656         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 657         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 658         Assert.assertNotNull(terminationPointNode);
 659
 660         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 661         for (TerminationPoint terminationPoint : terminationPoints) {
 662             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 663                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 664             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 665                 Long ofPort = ovsdbTerminationPointAugmentation.getOfport();
 666                 // if ephemeral port 45002 is in use, ofPort is set to 1
 667                 Assert.assertTrue(ofPort.equals(ofPortExpected) || ofPort.equals(new Long(1)));
 668                 LOG.info("ofPort: {}", ofPort);
 669             }
 670         }
 671         Assert.assertTrue(deleteBridge(connectionInfo));
 672     }
 673
 674     @Test
 675     public void testTerminationPointOfPortRequest() throws InterruptedException {
 676         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 677         connectOvsdbNode(connectionInfo);
 678         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 679         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 680         Assert.assertNotNull(bridge);
 681         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 682                 connectionInfo, bridge.getBridgeName()));
 683         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 684                 createGenericOvsdbTerminationPointAugmentationBuilder();
 685         String portName = "testOfPortRequest";
 686         ovsdbTerminationBuilder.setName(portName);
 687         Long ofPortExpected = new Long(45008);
 688         Integer ofPortRequestExpected = ofPortExpected.intValue();
 689         Long ofPortInput = new Long(45008);
 690         ovsdbTerminationBuilder.setOfport(ofPortInput);
 691         ovsdbTerminationBuilder.setOfportRequest(ofPortRequestExpected);
 692         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 693         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 694         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 695         Assert.assertNotNull(terminationPointNode);
 696
 697         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 698         for (TerminationPoint terminationPoint : terminationPoints) {
 699             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 700                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 701             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 702                 Long ofPort = ovsdbTerminationPointAugmentation.getOfport();
 703                 // if ephemeral port 45002 is in use, ofPort is set to 1
 704                 Assert.assertTrue(ofPort.equals(ofPortExpected) || ofPort.equals(new Long(1)));
 705                 LOG.info("ofPort: {}", ofPort);
 706
 707                 Integer ofPortRequest = ovsdbTerminationPointAugmentation.getOfportRequest();
 708                 Assert.assertTrue(ofPortRequest.equals(ofPortRequestExpected));
 709                 LOG.info("ofPortRequest: {}", ofPortRequest);
 710             }
 711         }
 712         Assert.assertTrue(deleteBridge(connectionInfo));
 713     }
 714
 715     @Test
 716     public void testTerminationPointPortExternalIds() throws InterruptedException {
 717         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 718         connectOvsdbNode(connectionInfo);
 719         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 720         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 721         Assert.assertNotNull(bridge);
 722         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 723                 connectionInfo, bridge.getBridgeName()));
 724         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 725                 createGenericOvsdbTerminationPointAugmentationBuilder();
 726         String portName = "testPortExternalIds";
 727         ovsdbTerminationBuilder.setName(portName);
 728         //setup
 729         PortExternalIdsBuilder externalIdsBuilder1 = new PortExternalIdsBuilder();
 730         externalIdsBuilder1.setExternalIdKey("portExternalIdKey1");
 731         externalIdsBuilder1.setExternalIdValue("portExternalIdValue1");
 732         PortExternalIdsBuilder externalIdsBuilder2 = new PortExternalIdsBuilder();
 733         externalIdsBuilder2.setExternalIdKey("portExternalIdKey2");
 734         externalIdsBuilder2.setExternalIdValue("portExternalIdValue2");
 735         List<PortExternalIds> portExternalIds = Lists.newArrayList(externalIdsBuilder1.build(),
 736                 externalIdsBuilder2.build());
 737         ovsdbTerminationBuilder.setPortExternalIds(portExternalIds);
 738
 739         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 740         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 741         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 742         Assert.assertNotNull(terminationPointNode);
 743
 744         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 745         for (TerminationPoint terminationPoint : terminationPoints) {
 746             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 747                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 748             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 749                 List<PortExternalIds> actualPortExternalIds = ovsdbTerminationPointAugmentation.getPortExternalIds();
 750                 Assert.assertTrue((portExternalIds.size() == actualPortExternalIds.size()));
 751                 for (PortExternalIds portExternalId : portExternalIds) {
 752                     Assert.assertTrue(actualPortExternalIds.contains(portExternalId));
 753                 }
 754             }
 755         }
 756         Assert.assertTrue(deleteBridge(connectionInfo));
 757     }
 758
 759     @Test
 760     public void testTerminationPointInterfaceExternalIds() throws InterruptedException {
 761         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 762         connectOvsdbNode(connectionInfo);
 763         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 764         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 765         Assert.assertNotNull(bridge);
 766         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 767                 connectionInfo, bridge.getBridgeName()));
 768         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 769                 createGenericOvsdbTerminationPointAugmentationBuilder();
 770         String portName = "testInterfaceExternalIds";
 771         ovsdbTerminationBuilder.setName(portName);
 772         //setup
 773         InterfaceExternalIdsBuilder externalIdsBuilder1 = new InterfaceExternalIdsBuilder();
 774         externalIdsBuilder1.setExternalIdKey("interfaceExternalIdKey1");
 775         externalIdsBuilder1.setExternalIdValue("interfaceExternalIdValue1");
 776         InterfaceExternalIdsBuilder externalIdsBuilder2 = new InterfaceExternalIdsBuilder();
 777         externalIdsBuilder2.setExternalIdKey("interfaceExternalIdKey2");
 778         externalIdsBuilder2.setExternalIdValue("interfaceExternalIdValue2");
 779         List<InterfaceExternalIds> interfaceExternalIds = Lists.newArrayList(externalIdsBuilder1.build(),
 780                 externalIdsBuilder2.build());
 781         ovsdbTerminationBuilder.setInterfaceExternalIds(interfaceExternalIds);
 782
 783         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 784         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 785         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 786         Assert.assertNotNull(terminationPointNode);
 787
 788         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 789         for (TerminationPoint terminationPoint : terminationPoints) {
 790             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 791                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 792             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 793                 List<InterfaceExternalIds> actualInterfaceExternalIds = ovsdbTerminationPointAugmentation.
 794                         getInterfaceExternalIds();
 795                 Assert.assertTrue((interfaceExternalIds.size() == actualInterfaceExternalIds.size()));
 796                 for (InterfaceExternalIds interfaceExternalId : interfaceExternalIds) {
 797                     Assert.assertTrue(actualInterfaceExternalIds.contains(interfaceExternalId));
 798                 }
 799             }
 800         }
 801         Assert.assertTrue(deleteBridge(connectionInfo));
 802     }
 803
 804     @Test
 805     public void testTerminationPointOptions() throws InterruptedException {
 806         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 807         connectOvsdbNode(connectionInfo);
 808         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 809         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 810         Assert.assertNotNull(bridge);
 811         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 812                 connectionInfo, bridge.getBridgeName()));
 813         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 814                 createGenericOvsdbTerminationPointAugmentationBuilder();
 815         String portName = "testInterfaceOptions";
 816         ovsdbTerminationBuilder.setName(portName);
 817         //setup
 818         OptionsBuilder optionsBuilder1 = new OptionsBuilder();
 819         optionsBuilder1.setOption("option1");
 820         optionsBuilder1.setValue("optionValue1");
 821         OptionsBuilder optionsBuilder2 = new OptionsBuilder();
 822         optionsBuilder2.setOption("option2");
 823         optionsBuilder2.setValue("optionValue2");
 824         List<Options> options = Lists.newArrayList(optionsBuilder1.build(),
 825                 optionsBuilder2.build());
 826         ovsdbTerminationBuilder.setOptions(options);
 827
 828         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 829         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 830         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 831         Assert.assertNotNull(terminationPointNode);
 832
 833         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 834         for (TerminationPoint terminationPoint : terminationPoints) {
 835             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 836                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 837             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 838                 List<Options> actualOptions = ovsdbTerminationPointAugmentation.
 839                         getOptions();
 840                 Assert.assertTrue((options.size() == actualOptions.size()));
 841                 for (Options option : options) {
 842                     Assert.assertTrue(actualOptions.contains(option));
 843                 }
 844             }
 845         }
 846         Assert.assertTrue(deleteBridge(connectionInfo));
 847     }
 848
 849     @Test
 850     public void testTerminationPointInterfaceOtherConfigs() throws InterruptedException {
 851         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 852         connectOvsdbNode(connectionInfo);
 853         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 854         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 855         Assert.assertNotNull(bridge);
 856         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 857                 connectionInfo, bridge.getBridgeName()));
 858         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 859                 createGenericOvsdbTerminationPointAugmentationBuilder();
 860         String portName = "testInterfaceOtherConfigs";
 861         ovsdbTerminationBuilder.setName(portName);
 862         //setup
 863         InterfaceOtherConfigsBuilder interfaceBuilder1 = new InterfaceOtherConfigsBuilder();
 864         interfaceBuilder1.setOtherConfigKey("interfaceOtherConfigsKey1");
 865         interfaceBuilder1.setOtherConfigValue("interfaceOtherConfigsValue1");
 866         InterfaceOtherConfigsBuilder interfaceBuilder2 = new InterfaceOtherConfigsBuilder();
 867         interfaceBuilder2.setOtherConfigKey("interfaceOtherConfigsKey2");
 868         interfaceBuilder2.setOtherConfigValue("interfaceOtherConfigsValue2");
 869         List<InterfaceOtherConfigs> interfaceOtherConfigs = Lists.newArrayList(interfaceBuilder1.build(),
 870                 interfaceBuilder2.build());
 871         ovsdbTerminationBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
 872
 873         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 874         Thread.sleep(1000);
 875         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 876         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 877         Assert.assertNotNull(terminationPointNode);
 878
 879         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 880         for (TerminationPoint terminationPoint : terminationPoints) {
 881             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 882                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 883             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 884                 List<InterfaceOtherConfigs> actualInterfaceOtherConfigs = ovsdbTerminationPointAugmentation.
 885                         getInterfaceOtherConfigs();
 886                 Assert.assertNotNull(actualInterfaceOtherConfigs);
 887                 Assert.assertNotNull(interfaceOtherConfigs);
 888                 Assert.assertTrue(interfaceOtherConfigs.size() == actualInterfaceOtherConfigs.size());
 889                 for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs) {
 890                     Assert.assertTrue(actualInterfaceOtherConfigs.contains(interfaceOtherConfig));
 891                 }
 892             }
 893         }
 894         Assert.assertTrue(deleteBridge(connectionInfo));
 895     }
 896
 897     @Test
 898     public void testTerminationPointPortOtherConfigs() throws InterruptedException {
 899         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 900         connectOvsdbNode(connectionInfo);
 901         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 902         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 903         Assert.assertNotNull(bridge);
 904         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 905                 connectionInfo, bridge.getBridgeName()));
 906         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 907                 createGenericOvsdbTerminationPointAugmentationBuilder();
 908         String portName = "testPortOtherConfigs";
 909         ovsdbTerminationBuilder.setName(portName);
 910         //setup
 911         PortOtherConfigsBuilder portBuilder1 = new PortOtherConfigsBuilder();
 912         portBuilder1.setOtherConfigKey("portOtherConfigsKey1");
 913         portBuilder1.setOtherConfigValue("portOtherConfigsValue1");
 914         PortOtherConfigsBuilder portBuilder2 = new PortOtherConfigsBuilder();
 915         portBuilder2.setOtherConfigKey("portOtherConfigsKey2");
 916         portBuilder2.setOtherConfigValue("portOtherConfigsValue2");
 917         List<PortOtherConfigs> portOtherConfigs = Lists.newArrayList(portBuilder1.build(),
 918                 portBuilder2.build());
 919         ovsdbTerminationBuilder.setPortOtherConfigs(portOtherConfigs);
 920
 921         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 922         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 923         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 924         Assert.assertNotNull(terminationPointNode);
 925
 926         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 927         for (TerminationPoint terminationPoint : terminationPoints) {
 928             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 929                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 930             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 931                 List<PortOtherConfigs> actualPortOtherConfigs = ovsdbTerminationPointAugmentation.
 932                         getPortOtherConfigs();
 933                 Assert.assertTrue((portOtherConfigs.size() == actualPortOtherConfigs.size()));
 934                 for (PortOtherConfigs portOtherConfig : portOtherConfigs) {
 935                     Assert.assertTrue(actualPortOtherConfigs.contains(portOtherConfig));
 936                 }
 937             }
 938         }
 939         Assert.assertTrue(deleteBridge(connectionInfo));
 940     }
 941
 942     @Test
 943     public void testTerminationPointVlan() throws InterruptedException {
 944         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 945         connectOvsdbNode(connectionInfo);
 946         Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 947         OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 948         Assert.assertNotNull(bridge);
 949         NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 950                 connectionInfo, bridge.getBridgeName()));
 951         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 952                 createGenericOvsdbTerminationPointAugmentationBuilder();
 953         String portName = "testTerminationPointVlanId";
 954         ovsdbTerminationBuilder.setName(portName);
 955         //setup
 956         Integer vlanId = new Integer(4000);
 957         ovsdbTerminationBuilder.setVlanTag(new VlanId(vlanId));
 958
 959         Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 960         InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 961         Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 962         Assert.assertNotNull(terminationPointNode);
 963
 964         List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
 965         for (TerminationPoint terminationPoint : terminationPoints) {
 966             OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 967                     terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
 968             if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 969                 //test
 970                 VlanId actualVlanId = ovsdbTerminationPointAugmentation.getVlanTag();
 971                 Assert.assertNotNull(actualVlanId);
 972                 Integer actualVlanIdInt = actualVlanId.getValue();
 973                 Assert.assertTrue(actualVlanIdInt.equals(vlanId));
 974             }
 975         }
 976         Assert.assertTrue(deleteBridge(connectionInfo));
 977     }
 978
 979     @Test
 980     public void testTerminationPointVlanModes() throws InterruptedException {
 981         VlanMode []vlanModes = VlanMode.values();
 982         for (VlanMode vlanMode : vlanModes) {
 983             ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
 984             connectOvsdbNode(connectionInfo);
 985             Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
 986             OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
 987             Assert.assertNotNull(bridge);
 988             NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
 989                     connectionInfo, bridge.getBridgeName()));
 990             OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
 991                     createGenericOvsdbTerminationPointAugmentationBuilder();
 992             String portName = "testTerminationPointVlanMode" + vlanMode.toString();
 993             ovsdbTerminationBuilder.setName(portName);
 994             //setup
 995             ovsdbTerminationBuilder.setVlanMode(vlanMode);
 996             Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
 997             InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
 998             Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
 999             Assert.assertNotNull(terminationPointNode);
1000
1001             List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
1002             for (TerminationPoint terminationPoint : terminationPoints) {
1003                 OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
1004                         terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
1005                 if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
1006                     //test
1007                     Assert.assertTrue(ovsdbTerminationPointAugmentation.getVlanMode().equals(vlanMode));
1008                 }
1009             }
1010             Assert.assertTrue(deleteBridge(connectionInfo));
1011         }
1012     }
1013
1014     private ArrayList<Set<Integer>> generateVlanSets() {
1015         ArrayList<Set<Integer>> vlanSets = new ArrayList<Set<Integer>>();
1016
1017         Set<Integer> emptySet = new HashSet<Integer>();
1018         vlanSets.add(emptySet);
1019
1020         Set<Integer> singleSet = new HashSet<Integer>();
1021         Integer single = new Integer(2222);
1022         singleSet.add(single);
1023         vlanSets.add(singleSet);
1024
1025         Set<Integer> minMaxMiddleSet = new HashSet<Integer>();
1026         Integer min = new Integer(0);
1027         minMaxMiddleSet.add(min);
1028         Integer max = new Integer(4095);
1029         minMaxMiddleSet.add(max);
1030         Integer minPlusOne = new Integer(min + 1);
1031         minMaxMiddleSet.add(minPlusOne);
1032         Integer maxMinusOne = new Integer(max - 1);
1033         minMaxMiddleSet.add(maxMinusOne);
1034         Integer middle = new Integer((max - min) / 2);
1035         minMaxMiddleSet.add(middle);
1036         vlanSets.add(minMaxMiddleSet);
1037
1038         return vlanSets;
1039     }
1040
1041     private List<Trunks> buildTrunkList(Set<Integer> trunkSet) {
1042         List<Trunks> trunkList = Lists.newArrayList();
1043         for (Integer trunk : trunkSet) {
1044             TrunksBuilder trunkBuilder = new TrunksBuilder();
1045             trunkBuilder.setTrunk(new VlanId(trunk));
1046             trunkList.add(trunkBuilder.build());
1047         }
1048         return trunkList;
1049     }
1050
1051     @Test
1052     public void testTerminationPointVlanTrunks() throws InterruptedException {
1053         ArrayList<Set<Integer>> vlanSets = generateVlanSets();
1054         int testCase = 0;
1055         for (Set<Integer> vlanSet : vlanSets) {
1056             ++testCase;
1057             ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
1058             connectOvsdbNode(connectionInfo);
1059             Assert.assertTrue(addBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME));
1060             OvsdbBridgeAugmentation bridge = getBridge(connectionInfo);
1061             Assert.assertNotNull(bridge);
1062             NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundMapper.createInstanceIdentifier(
1063                     connectionInfo, bridge.getBridgeName()));
1064             OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
1065                     createGenericOvsdbTerminationPointAugmentationBuilder();
1066             String portName = "testTerminationPointVlanTrunks" + testCase;
1067             ovsdbTerminationBuilder.setName(portName);
1068             //setup
1069             List<Trunks> trunks = buildTrunkList(vlanSet);
1070             ovsdbTerminationBuilder.setTrunks(trunks);
1071             Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
1072             InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
1073             Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
1074             Assert.assertNotNull(terminationPointNode);
1075
1076             List<TerminationPoint> terminationPoints = terminationPointNode.getTerminationPoint();
1077             for (TerminationPoint terminationPoint : terminationPoints) {
1078                 OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
1079                         terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
1080                 if (ovsdbTerminationPointAugmentation.getName().equals(portName)) {
1081                     List<Trunks> actualTrunks = ovsdbTerminationPointAugmentation.getTrunks();
1082                     for (Trunks trunk : trunks) {
1083                         Assert.assertTrue(actualTrunks.contains(trunk));
1084                     }
1085                 }
1086             }
1087             Assert.assertTrue(deleteBridge(connectionInfo));
1088         }
1089     }
1090
1091     @Test
1092     public void testGetOvsdbNodes() throws InterruptedException {
1093         ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
1094         connectOvsdbNode(connectionInfo);
1095         InstanceIdentifier<Topology> topologyPath = InstanceIdentifier
1096                 .create(NetworkTopology.class)
1097                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
1098
1099         Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, topologyPath);
1100         Assert.assertEquals("There should only be one node in the topology", 1, topology.getNode().size());
1101         InstanceIdentifier<Node> expectedNodeIid = SouthboundMapper.createInstanceIdentifier(connectionInfo);
1102         Node node = topology.getNode().iterator().next();
1103         NodeId expectedNodeId = expectedNodeIid.firstKeyOf(Node.class, NodeKey.class).getNodeId();
1104         Assert.assertEquals(expectedNodeId, node.getNodeId());
1105         Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
1106     }
1107
1108     /**
1109      * isBundleReady is used to check if the requested bundle is Active
1110      */
1111     public void isBundleReady(BundleContext bundleContext, String bundleName) throws InterruptedException {
1112         boolean ready = false;
1113
1114         while (!ready) {
1115             int state = Bundle.UNINSTALLED;
1116             Bundle[] bundles = bundleContext.getBundles();
1117             for (Bundle element : bundles) {
1118                 if (element.getSymbolicName().equals(bundleName)) {
1119                     state = element.getState();
1120                     LOG.info(">>>>> bundle is ready {}", bundleName);
1121                     break;
1122                 }
1123             }
1124             if (state != Bundle.ACTIVE) {
1125                 LOG.info(">>>>> bundle not ready {}", bundleName);
1126                 Thread.sleep(5000);
1127             } else {
1128                 ready = true;
1129             }
1130         }
1131     }
1132 }