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