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