netvirt/it/src/test/java/org/opendaylight/netvirt/netvirt/it/NetvirtIT.java

   1 /*
   2  * Copyright © 2016 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
   9 package org.opendaylight.netvirt.netvirt.it;
  10
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.ops4j.pax.exam.CoreOptions.composite;
  15 import static org.ops4j.pax.exam.CoreOptions.maven;
  16 import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
  17 import static org.ops4j.pax.exam.CoreOptions.propagateSystemProperties;
  18 import static org.ops4j.pax.exam.CoreOptions.vmOption;
  19 import static org.ops4j.pax.exam.CoreOptions.wrappedBundle;
  20 import static org.ops4j.pax.exam.MavenUtils.asInProject;
  21 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.configureConsole;
  22 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
  23 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;
  24
  25 import java.util.ArrayList;
  26 import java.util.Iterator;
  27 import java.util.List;
  28 import java.util.Properties;
  29 import java.util.concurrent.atomic.AtomicBoolean;
  30 import org.junit.After;
  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.controller.mdsal.it.base.AbstractMdsalTestBase;
  37 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  38 import org.opendaylight.neutron.spi.NeutronNetwork;
  39 import org.opendaylight.netvirt.utils.it.utils.ItConstants;
  40 import org.opendaylight.netvirt.utils.it.utils.ItUtils;
  41 import org.opendaylight.netvirt.utils.neutron.utils.NeutronModelsDataStoreHelper;
  42 import org.opendaylight.netvirt.utils.neutron.utils.NeutronUtils;
  43 import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
  44 import org.opendaylight.ovsdb.utils.mdsal.utils.NotifyingDataChangeListener;
  45 import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  49 import org.ops4j.pax.exam.Configuration;
  50 import org.ops4j.pax.exam.Option;
  51 import org.ops4j.pax.exam.junit.PaxExam;
  52 import org.ops4j.pax.exam.karaf.options.LogLevelOption;
  53 import org.ops4j.pax.exam.options.MavenUrlReference;
  54 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
  55 import org.ops4j.pax.exam.spi.reactors.PerClass;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 @RunWith(PaxExam.class)
  60 @ExamReactorStrategy(PerClass.class)
  61 public class NetvirtIT extends AbstractMdsalTestBase {
  62     private static final Logger LOG = LoggerFactory.getLogger(NetvirtIT.class);
  63     private static final String FEATURE = "odl-netvirt-it";
  64     private static DataBroker dataBroker = null;
  65     private static ItUtils itUtils;
  66     private static String addressStr;
  67     private static String portStr;
  68     private static String connectionType;
  69     private static String controllerStr;
  70     private static AtomicBoolean setup = new AtomicBoolean(false);
  71     private static MdsalUtils mdsalUtils = null;
  72     private static SouthboundUtils southboundUtils;
  73     private static NeutronUtils neutronUtils = new NeutronUtils();
  74     private static NeutronModelsDataStoreHelper neutronModelsDataStoreHelper;
  75     private static final String NETWORK_TYPE_VXLAN = "vxlan";
  76
  77     @Override
  78     public String getModuleName() {
  79         return "netvirt-neutron";
  80     }
  81
  82     @Override
  83     public String getInstanceName() {
  84         return "netvirt-neutron-default";
  85     }
  86
  87     @Override
  88     public MavenUrlReference getFeatureRepo() {
  89         return maven()
  90                 .groupId("org.opendaylight.netvirt")
  91                 .artifactId("features-netvirt")
  92                 .classifier("features")
  93                 .type("xml")
  94                 .versionAsInProject();
  95     }
  96
  97     @Override
  98     public String getFeatureName() {
  99         return FEATURE;
 100     }
 101
 102     @Configuration
 103     @Override
 104     public Option[] config() {
 105         Option[] parentOptions = super.config();
 106         Option[] propertiesOptions = getPropertiesOptions();
 107         Option[] otherOptions = getOtherOptions();
 108         Option[] options = new Option[parentOptions.length + propertiesOptions.length + otherOptions.length];
 109         System.arraycopy(parentOptions, 0, options, 0, parentOptions.length);
 110         System.arraycopy(propertiesOptions, 0, options, parentOptions.length, propertiesOptions.length);
 111         System.arraycopy(otherOptions, 0, options, parentOptions.length + propertiesOptions.length,
 112                 otherOptions.length);
 113         return options;
 114     }
 115
 116     private Option[] getOtherOptions() {
 117         return new Option[] {
 118                 wrappedBundle(
 119                         mavenBundle("org.opendaylight.netvirt", "utils.mdsal-openflow")
 120                                 .version(asInProject())
 121                                 .type("jar")),
 122                 configureConsole().startLocalConsole(),
 123                 //vmOption("-verbose:class"),
 124                 vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
 125                 keepRuntimeFolder()
 126         };
 127     }
 128
 129     private Option[] getPropertiesOptions() {
 130         return new Option[] {
 131                 propagateSystemProperties(ItConstants.SERVER_IPADDRESS, ItConstants.SERVER_PORT,
 132                         ItConstants.CONNECTION_TYPE, ItConstants.CONTROLLER_IPADDRESS,
 133                         ItConstants.USERSPACE_ENABLED),
 134         };
 135     }
 136
 137     @Override
 138     public Option getLoggingOption() {
 139         return composite(
 140                 editConfigurationFilePut(ItConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 141                         "log4j.logger.org.opendaylight.ovsdb",
 142                         LogLevelOption.LogLevel.TRACE.name()),
 143                 editConfigurationFilePut(ItConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 144                         logConfiguration(NetvirtIT.class),
 145                         LogLevelOption.LogLevel.INFO.name()),
 146                 editConfigurationFilePut(ItConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 147                         "log4j.logger.org.opendaylight.neutron",
 148                         LogLevelOption.LogLevel.TRACE.name()),
 149                 super.getLoggingOption());
 150     }
 151
 152     protected String usage() {
 153         return "Integration Test needs a valid connection configuration as follows :\n"
 154                 + "active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify\n"
 155                 + "passive connection : mvn -Dovsdbserver.connection=passive verify\n";
 156     }
 157
 158     private void getProperties() {
 159         Properties props = System.getProperties();
 160         addressStr = props.getProperty(ItConstants.SERVER_IPADDRESS);
 161         portStr = props.getProperty(ItConstants.SERVER_PORT, ItConstants.DEFAULT_SERVER_PORT);
 162         connectionType = props.getProperty(ItConstants.CONNECTION_TYPE, "active");
 163         controllerStr = props.getProperty(ItConstants.CONTROLLER_IPADDRESS, "0.0.0.0");
 164         String userSpaceEnabled = props.getProperty(ItConstants.USERSPACE_ENABLED, "no");
 165         LOG.info("setUp: Using the following properties: mode= {}, ip:port= {}:{}, controller ip: {}, " +
 166                         "userspace.enabled: {}",
 167                 connectionType, addressStr, portStr, controllerStr, userSpaceEnabled);
 168         if (connectionType.equalsIgnoreCase(ItConstants.CONNECTION_TYPE_ACTIVE)) {
 169             if (addressStr == null) {
 170                 fail(usage());
 171             }
 172         }
 173     }
 174
 175     @After
 176     public void teardown() {
 177         closeWaitFors();
 178     }
 179
 180     @Before
 181     @Override
 182     public void setup() throws InterruptedException {
 183         if (setup.get()) {
 184             LOG.info("Skipping setUp, already initialized");
 185             return;
 186         }
 187
 188         try {
 189             super.setup();
 190         } catch (Exception e) {
 191             LOG.warn("Failed to setup test", e);
 192             fail("Failed to setup test: " + e);
 193         }
 194
 195         getProperties();
 196
 197         if (connectionType.equalsIgnoreCase(ItConstants.CONNECTION_TYPE_ACTIVE)) {
 198             if (addressStr == null) {
 199                 fail(usage());
 200             }
 201         }
 202
 203         dataBroker = ItUtils.getDatabroker(getProviderContext());
 204         itUtils = new ItUtils(dataBroker);
 205         mdsalUtils = new MdsalUtils(dataBroker);
 206         assertNotNull("mdsalUtils should not be null", mdsalUtils);
 207         // TODO: Not used yet since openstack is not running to write the netvirt:1 to mdsal
 208         // Only need neutron northbound right now
 209         //assertTrue("Did not find " + ItConstants.NETVIRT_TOPOLOGY_ID, itUtils.getNetvirtTopology());
 210         southboundUtils = new SouthboundUtils(mdsalUtils);
 211         neutronModelsDataStoreHelper = new NeutronModelsDataStoreHelper(dataBroker);
 212         setup.set(true);
 213     }
 214
 215     private BindingAwareBroker.ProviderContext getProviderContext() {
 216         BindingAwareBroker.ProviderContext providerContext = null;
 217         for (int i=0; i < 60; i++) {
 218             providerContext = getSession();
 219             if (providerContext != null) {
 220                 break;
 221             } else {
 222                 try {
 223                     Thread.sleep(1000);
 224                 } catch (InterruptedException e) {
 225                     LOG.warn("Interrupted while waiting for provider context", e);
 226                 }
 227             }
 228         }
 229         assertNotNull("providercontext should not be null", providerContext);
 230         /* One more second to let the provider finish initialization */
 231         try {
 232             Thread.sleep(1000);
 233         } catch (InterruptedException e) {
 234             LOG.warn("Interrupted while waiting for other provider", e);
 235         }
 236         return providerContext;
 237     }
 238
 239     @Test
 240     public void testNetvirtFeatureLoad() {
 241         assertTrue("Feature " + FEATURE + " was not loaded", true);
 242     }
 243
 244     private List<NotifyingDataChangeListener> waitList = new ArrayList<>();
 245     private void closeWaitFors() {
 246         for (Iterator<NotifyingDataChangeListener> iterator = waitList.iterator(); iterator.hasNext();) {
 247             NotifyingDataChangeListener listener = iterator.next();
 248             iterator.remove();
 249             try {
 250                 listener.close();
 251             } catch (Exception ex) {
 252                 LOG.warn("Failed to close registration {}", listener, ex);
 253             }
 254         }
 255         LOG.info("waitList size {}", waitList.size());
 256     }
 257
 258     @Test
 259     public void testNetvirtNeutron() throws InterruptedException {
 260         final String networkId = "521e29d6-67b8-4b3c-8633-027d21195111";
 261         final String tenantId = "521e29d6-67b8-4b3c-8633-027d21195100";
 262
 263         InstanceIdentifier<Network> path = neutronModelsDataStoreHelper.getNeutronNetworkPath(new Uuid(networkId));
 264         final NotifyingDataChangeListener networkOperationalListener =
 265                 new NotifyingDataChangeListener(LogicalDatastoreType.CONFIGURATION, path, waitList);
 266         networkOperationalListener.registerDataChangeListener(dataBroker);
 267
 268         NeutronNetwork nn = neutronUtils.createNeutronNetwork(networkId, tenantId,
 269                 NETWORK_TYPE_VXLAN, "100");
 270
 271         networkOperationalListener.waitForCreation();
 272
 273         Network network = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, path);
 274         assertNotNull("the network was not found in mdsal", network);
 275     }
 276 }