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