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 javax.inject.Inject;
  31 import org.junit.After;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  36 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  37 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
  38 import org.opendaylight.netvirt.openstack.netvirt.NeutronModelsDataStoreHelper;
  39 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.NeutronNetwork;
  40 import org.opendaylight.netvirt.utils.netvirt.it.utils.ItConstants;
  41 import org.opendaylight.netvirt.utils.netvirt.it.utils.NetvirtItUtils;
  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.ops4j.pax.exam.util.Filter;
  57 import org.slf4j.Logger;
  58 import org.slf4j.LoggerFactory;
  59
  60 @RunWith(PaxExam.class)
  61 @ExamReactorStrategy(PerClass.class)
  62 public class NetvirtIT extends AbstractMdsalTestBase {
  63     private static final Logger LOG = LoggerFactory.getLogger(NetvirtIT.class);
  64     private static final String FEATURE = "odl-netvirt-it";
  65     private static NetvirtItUtils 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     @Inject @Filter(timeout=60000)
  77     private static DataBroker dataBroker = null;
  78
  79
  80     @Override
  81     public String getModuleName() {
  82         return "netvirt-neutron";
  83     }
  84
  85     @Override
  86     public String getInstanceName() { return "netvirt-neutron"; }
  87
  88     @Override
  89     public MavenUrlReference getFeatureRepo() {
  90         return maven()
  91                 .groupId("org.opendaylight.netvirt")
  92                 .artifactId("features-netvirt")
  93                 .classifier("features")
  94                 .type("xml")
  95                 .versionAsInProject();
  96     }
  97
  98     @Override
  99     public String getFeatureName() {
 100         return FEATURE;
 101     }
 102
 103     @Configuration
 104     @Override
 105     public Option[] config() {
 106         Option[] parentOptions = super.config();
 107         Option[] propertiesOptions = getPropertiesOptions();
 108         Option[] otherOptions = getOtherOptions();
 109         Option[] options = new Option[parentOptions.length + propertiesOptions.length + otherOptions.length];
 110         System.arraycopy(parentOptions, 0, options, 0, parentOptions.length);
 111         System.arraycopy(propertiesOptions, 0, options, parentOptions.length, propertiesOptions.length);
 112         System.arraycopy(otherOptions, 0, options, parentOptions.length + propertiesOptions.length,
 113                 otherOptions.length);
 114         return options;
 115     }
 116
 117     private Option[] getOtherOptions() {
 118         return new Option[] {
 119                 wrappedBundle(
 120                         mavenBundle("org.opendaylight.netvirt", "utils.mdsal-openflow")
 121                                 .version(asInProject())
 122                                 .type("jar")),
 123                 configureConsole().startLocalConsole(),
 124                 //vmOption("-verbose:class"),
 125                 vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
 126                 keepRuntimeFolder()
 127         };
 128     }
 129
 130     private Option[] getPropertiesOptions() {
 131         return new Option[] {
 132                 propagateSystemProperties(ItConstants.SERVER_IPADDRESS, ItConstants.SERVER_PORT,
 133                         ItConstants.CONNECTION_TYPE, ItConstants.CONTROLLER_IPADDRESS,
 134                         ItConstants.USERSPACE_ENABLED),
 135         };
 136     }
 137
 138     @Override
 139     public Option getLoggingOption() {
 140         return composite(
 141                 editConfigurationFilePut(ItConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 142                         "log4j.logger.org.opendaylight.ovsdb",
 143                         LogLevelOption.LogLevel.TRACE.name()),
 144                 editConfigurationFilePut(ItConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 145                         logConfiguration(NetvirtIT.class),
 146                         LogLevelOption.LogLevel.INFO.name()),
 147                 editConfigurationFilePut(ItConstants.ORG_OPS4J_PAX_LOGGING_CFG,
 148                         "log4j.logger.org.opendaylight.neutron",
 149                         LogLevelOption.LogLevel.TRACE.name()),
 150                 super.getLoggingOption());
 151     }
 152
 153     protected String usage() {
 154         return "Integration Test needs a valid connection configuration as follows :\n"
 155                 + "active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify\n"
 156                 + "passive connection : mvn -Dovsdbserver.connection=passive verify\n";
 157     }
 158
 159     private void getProperties() {
 160         Properties props = System.getProperties();
 161         addressStr = props.getProperty(ItConstants.SERVER_IPADDRESS);
 162         portStr = props.getProperty(ItConstants.SERVER_PORT, ItConstants.DEFAULT_SERVER_PORT);
 163         connectionType = props.getProperty(ItConstants.CONNECTION_TYPE, "active");
 164         controllerStr = props.getProperty(ItConstants.CONTROLLER_IPADDRESS, "0.0.0.0");
 165         String userSpaceEnabled = props.getProperty(ItConstants.USERSPACE_ENABLED, "no");
 166         LOG.info("setUp: Using the following properties: mode= {}, ip:port= {}:{}, controller ip: {}, " +
 167                         "userspace.enabled: {}",
 168                 connectionType, addressStr, portStr, controllerStr, userSpaceEnabled);
 169         if (connectionType.equalsIgnoreCase(ItConstants.CONNECTION_TYPE_ACTIVE)) {
 170             if (addressStr == null) {
 171                 fail(usage());
 172             }
 173         }
 174     }
 175
 176     @After
 177     public void teardown() {
 178         closeWaitFors();
 179     }
 180
 181     @Before
 182     @Override
 183     public void setup() throws InterruptedException {
 184         if (setup.get()) {
 185             LOG.info("Skipping setUp, already initialized");
 186             return;
 187         }
 188
 189         try {
 190             super.setup();
 191         } catch (Exception e) {
 192             LOG.warn("Failed to setup test", e);
 193             fail("Failed to setup test: " + e);
 194         }
 195
 196         getProperties();
 197
 198         if (connectionType.equalsIgnoreCase(ItConstants.CONNECTION_TYPE_ACTIVE)) {
 199             if (addressStr == null) {
 200                 fail(usage());
 201             }
 202         }
 203
 204         assertNotNull("dataBroker should not be null", dataBroker);
 205         itUtils = new NetvirtItUtils(dataBroker);
 206         mdsalUtils = new MdsalUtils(dataBroker);
 207         assertNotNull("mdsalUtils should not be null", mdsalUtils);
 208         // TODO: Not used yet since openstack is not running to write the netvirt:1 to mdsal
 209         // Only need neutron northbound right now
 210         //assertTrue("Did not find " + ItConstants.NETVIRT_TOPOLOGY_ID, itUtils.getNetvirtTopology());
 211         southboundUtils = new SouthboundUtils(mdsalUtils);
 212         neutronModelsDataStoreHelper = new NeutronModelsDataStoreHelper(dataBroker);
 213         setup.set(true);
 214     }
 215
 216     @Test
 217     public void testNetvirtFeatureLoad() {
 218         assertTrue("Feature " + FEATURE + " was not loaded", true);
 219     }
 220
 221     private List<NotifyingDataChangeListener> waitList = new ArrayList<>();
 222     private void closeWaitFors() {
 223         for (Iterator<NotifyingDataChangeListener> iterator = waitList.iterator(); iterator.hasNext();) {
 224             NotifyingDataChangeListener listener = iterator.next();
 225             iterator.remove();
 226             try {
 227                 listener.close();
 228             } catch (Exception ex) {
 229                 LOG.warn("Failed to close registration {}", listener, ex);
 230             }
 231         }
 232         LOG.info("waitList size {}", waitList.size());
 233     }
 234
 235     @Test
 236     public void testNetvirtNeutron() throws InterruptedException {
 237         final String networkId = "521e29d6-67b8-4b3c-8633-027d21195111";
 238         final String tenantId = "521e29d6-67b8-4b3c-8633-027d21195100";
 239
 240         InstanceIdentifier<Network> path = neutronModelsDataStoreHelper.getNeutronNetworkPath(new Uuid(networkId));
 241         final NotifyingDataChangeListener networkOperationalListener =
 242                 new NotifyingDataChangeListener(LogicalDatastoreType.CONFIGURATION, path, waitList);
 243         networkOperationalListener.registerDataChangeListener(dataBroker);
 244
 245         NeutronNetwork nn = neutronUtils.createNeutronNetwork(networkId, tenantId,
 246                 NETWORK_TYPE_VXLAN, "100");
 247
 248         networkOperationalListener.waitForCreation();
 249
 250         Network network = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, path);
 251         assertNotNull("the network was not found in mdsal", network);
 252     }
 253 }