2 * Copyright (c) 2015 Red Hat, Inc. and others. All rights reserved.
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
8 package org.opendaylight.ovsdb.openstack.netvirt.it;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertTrue;
14 import static org.junit.Assert.fail;
15 import static org.junit.Assume.assumeTrue;
16 import static org.ops4j.pax.exam.CoreOptions.composite;
17 import static org.ops4j.pax.exam.CoreOptions.maven;
18 import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
19 import static org.ops4j.pax.exam.CoreOptions.propagateSystemProperties;
20 import static org.ops4j.pax.exam.CoreOptions.vmOption;
21 import static org.ops4j.pax.exam.CoreOptions.wrappedBundle;
22 import static org.ops4j.pax.exam.MavenUtils.asInProject;
23 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.configureConsole;
24 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
25 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;
27 import com.google.common.collect.Lists;
28 import com.google.common.collect.Maps;
30 import java.net.InetAddress;
31 import java.net.NetworkInterface;
32 import java.net.UnknownHostException;
33 import java.util.ArrayList;
34 import java.util.Enumeration;
35 import java.util.List;
37 import java.util.Properties;
38 import java.util.concurrent.atomic.AtomicBoolean;
40 import org.junit.Assert;
41 import org.junit.Before;
42 import org.junit.Ignore;
43 import org.junit.Test;
44 import org.junit.runner.RunWith;
45 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
46 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
47 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
48 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
49 import org.opendaylight.neutron.spi.INeutronPortCRUD;
50 import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
51 import org.opendaylight.neutron.spi.INeutronSecurityRuleCRUD;
52 import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
53 import org.opendaylight.neutron.spi.NeutronPort;
54 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
55 import org.opendaylight.neutron.spi.NeutronSecurityGroup;
56 import org.opendaylight.neutron.spi.NeutronSecurityRule;
57 import org.opendaylight.neutron.spi.NeutronNetwork;
58 import org.opendaylight.neutron.spi.NeutronSubnet;
59 import org.opendaylight.ovsdb.lib.notation.Version;
60 import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
61 import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
62 import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
63 import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.PipelineOrchestrator;
64 import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
65 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
66 import org.opendaylight.ovsdb.utils.config.ConfigProperties;
67 import org.opendaylight.ovsdb.utils.mdsal.openflow.FlowUtils;
68 import org.opendaylight.ovsdb.utils.mdsal.openflow.MatchUtils;
69 import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
70 import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
71 import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
72 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
73 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
74 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
87 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
89 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
90 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
91 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
92 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
93 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
94 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
95 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
96 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
97 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
98 import org.ops4j.pax.exam.Configuration;
99 import org.ops4j.pax.exam.Option;
100 import org.ops4j.pax.exam.junit.PaxExam;
101 import org.ops4j.pax.exam.karaf.options.LogLevelOption;
102 import org.ops4j.pax.exam.options.MavenUrlReference;
103 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
104 import org.ops4j.pax.exam.spi.reactors.PerClass;
105 import org.slf4j.Logger;
106 import org.slf4j.LoggerFactory;
109 * Integration tests for netvirt
111 * @author Sam Hague (shague@redhat.com)
113 @RunWith(PaxExam.class)
114 @ExamReactorStrategy(PerClass.class)
115 public class NetvirtIT extends AbstractMdsalTestBase {
116 private static final Logger LOG = LoggerFactory.getLogger(NetvirtIT.class);
117 private static final int OVSDB_UPDATE_TIMEOUT = 1000;
118 private static DataBroker dataBroker = null;
119 private static String addressStr;
120 private static String portStr;
121 private static String connectionType;
122 private static String controllerStr;
123 private static AtomicBoolean setup = new AtomicBoolean(false);
124 private static MdsalUtils mdsalUtils = null;
125 private static Southbound southbound = null;
126 private static SouthboundUtils southboundUtils;
127 private static final String NETVIRT_TOPOLOGY_ID = "netvirt:1";
128 private static final String SDPLNAME = "sg1";
129 private static final String NETWORK_ID = "521e29d6-67b8-4b3c-8633-027d21195111";
130 private static final String TENANT_ID = "521e29d6-67b8-4b3c-8633-027d21195100";
131 private static final String SUBNET_ID = "521e29d6-67b8-4b3c-8633-027d21195112";
132 private static final String PORT1_ID = "521e29d6-67b8-4b3c-8633-027d21195113";
133 private static final String DHCPPORT_ID ="521e29d6-67b8-4b3c-8633-027d21195115";
136 public String getModuleName() {
137 return "netvirt-providers-impl";
141 public String getInstanceName() {
142 return "netvirt-providers-default";
146 public MavenUrlReference getFeatureRepo() {
148 .groupId("org.opendaylight.ovsdb")
149 .artifactId("features-ovsdb")
150 .classifier("features")
152 .versionAsInProject();
156 public String getFeatureName() {
157 return "odl-ovsdb-openstack";
162 public Option[] config() {
163 Option[] parentOptions = super.config();
164 Option[] propertiesOptions = getPropertiesOptions();
165 Option[] otherOptions = getOtherOptions();
166 Option[] options = new Option[parentOptions.length + propertiesOptions.length + otherOptions.length];
167 System.arraycopy(parentOptions, 0, options, 0, parentOptions.length);
168 System.arraycopy(propertiesOptions, 0, options, parentOptions.length, propertiesOptions.length);
169 System.arraycopy(otherOptions, 0, options, parentOptions.length + propertiesOptions.length,
170 otherOptions.length);
174 private Option[] getOtherOptions() {
175 return new Option[] {
177 mavenBundle("org.opendaylight.ovsdb", "utils.mdsal-openflow")
178 .version(asInProject())
181 mavenBundle("org.opendaylight.ovsdb", "utils.config")
182 .version(asInProject())
184 configureConsole().startLocalConsole(),
185 vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
190 public Option[] getPropertiesOptions() {
191 return new Option[] {
192 propagateSystemProperties(NetvirtITConstants.SERVER_IPADDRESS,
193 NetvirtITConstants.SERVER_PORT, NetvirtITConstants.CONNECTION_TYPE,
194 NetvirtITConstants.CONTROLLER_IPADDRESS,
195 NetvirtITConstants.USERSPACE_ENABLED)
200 public Option getLoggingOption() {
202 //editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
203 // "log4j.logger.org.opendaylight.controller",
204 // LogLevelOption.LogLevel.TRACE.name()),
205 editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
206 "log4j.logger.org.opendaylight.ovsdb",
207 LogLevelOption.LogLevel.TRACE.name()),
208 editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
209 logConfiguration(NetvirtIT.class),
210 LogLevelOption.LogLevel.INFO.name()),
211 editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
212 "log4j.logger.org.opendaylight.ovsdb.lib",
213 LogLevelOption.LogLevel.INFO.name()),
214 super.getLoggingOption());
217 protected String usage() {
218 return "Integration Test needs a valid connection configuration as follows :\n"
219 + "active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify\n"
220 + "passive connection : mvn -Dovsdbserver.connection=passive verify\n";
223 private void getProperties() {
224 Properties props = System.getProperties();
225 addressStr = props.getProperty(NetvirtITConstants.SERVER_IPADDRESS);
226 portStr = props.getProperty(NetvirtITConstants.SERVER_PORT, NetvirtITConstants.DEFAULT_SERVER_PORT);
227 connectionType = props.getProperty(NetvirtITConstants.CONNECTION_TYPE, "active");
228 controllerStr = props.getProperty(NetvirtITConstants.CONTROLLER_IPADDRESS, "0.0.0.0");
229 String userSpaceEnabled = props.getProperty(NetvirtITConstants.USERSPACE_ENABLED, "no");
230 LOG.info("setUp: Using the following properties: mode= {}, ip:port= {}:{}, controller ip: {}, " +
231 "userspace.enabled: {}",
232 connectionType, addressStr, portStr, controllerStr, userSpaceEnabled);
233 if (connectionType.equalsIgnoreCase(NetvirtITConstants.CONNECTION_TYPE_ACTIVE)) {
234 if (addressStr == null) {
242 public void setup() throws InterruptedException {
244 LOG.info("Skipping setUp, already initialized");
250 } catch (Exception e) {
256 if (connectionType.equalsIgnoreCase(NetvirtITConstants.CONNECTION_TYPE_ACTIVE)) {
257 if (addressStr == null) {
262 dataBroker = getDatabroker(getProviderContext());
263 mdsalUtils = new MdsalUtils(dataBroker);
264 assertNotNull("mdsalUtils should not be null", mdsalUtils);
265 assertTrue("Did not find " + NETVIRT_TOPOLOGY_ID, getNetvirtTopology());
266 southbound = (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
267 assertNotNull("southbound should not be null", southbound);
268 southboundUtils = new SouthboundUtils(mdsalUtils);
272 private BindingAwareBroker.ProviderContext getProviderContext() {
273 BindingAwareBroker.ProviderContext providerContext = null;
274 for (int i=0; i < 60; i++) {
275 providerContext = getSession();
276 if (providerContext != null) {
281 } catch (InterruptedException e) {
286 assertNotNull("providercontext should not be null", providerContext);
287 /* One more second to let the provider finish initialization */
290 } catch (InterruptedException e) {
293 return providerContext;
296 private DataBroker getDatabroker(BindingAwareBroker.ProviderContext providerContext) {
297 DataBroker dataBroker = providerContext.getSALService(DataBroker.class);
298 assertNotNull("dataBroker should not be null", dataBroker);
302 private Boolean getNetvirtTopology() {
303 LOG.info("getNetvirtTopology: looking for {}...", NETVIRT_TOPOLOGY_ID);
304 Boolean found = false;
305 final TopologyId topologyId = new TopologyId(new Uri(NETVIRT_TOPOLOGY_ID));
306 InstanceIdentifier<Topology> path =
307 InstanceIdentifier.create(NetworkTopology.class).child(Topology.class, new TopologyKey(topologyId));
308 for (int i = 0; i < 60; i++) {
309 Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, path);
310 if (topology != null) {
311 LOG.info("getNetvirtTopology: found {}...", NETVIRT_TOPOLOGY_ID);
315 LOG.info("getNetvirtTopology: still looking ({})...", i);
318 } catch (InterruptedException e) {
327 * Test passive connection mode. The southbound starts in a listening mode waiting for connections on port
328 * 6640. This test will wait for incoming connections for {@link NetvirtITConstants#CONNECTION_INIT_TIMEOUT} ms.
330 * @throws InterruptedException
334 public void testPassiveNode() throws InterruptedException {
335 if (connectionType.equalsIgnoreCase(NetvirtITConstants.CONNECTION_TYPE_PASSIVE)) {
336 //Wait for CONNECTION_INIT_TIMEOUT for the Passive connection to be initiated by the ovsdb-server.
337 Thread.sleep(NetvirtITConstants.CONNECTION_INIT_TIMEOUT);
341 private ConnectionInfo getConnectionInfo(final String addressStr, final String portStr) {
342 InetAddress inetAddress = null;
344 inetAddress = InetAddress.getByName(addressStr);
345 } catch (UnknownHostException e) {
346 fail("Could not allocate InetAddress: " + e);
349 IpAddress address = SouthboundMapper.createIpAddress(inetAddress);
350 PortNumber port = new PortNumber(Integer.parseInt(portStr));
352 LOG.info("connectionInfo: {}", new ConnectionInfoBuilder()
353 .setRemoteIp(address)
356 return new ConnectionInfoBuilder()
357 .setRemoteIp(address)
362 private String connectionInfoToString(final ConnectionInfo connectionInfo) {
363 return String.valueOf(connectionInfo.getRemoteIp().getValue()) + ":" + connectionInfo.getRemotePort().getValue();
366 private boolean addOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
367 boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
368 SouthboundUtils.createInstanceIdentifier(connectionInfo),
369 SouthboundUtils.createNode(connectionInfo));
370 Thread.sleep(OVSDB_UPDATE_TIMEOUT);
374 private Node getOvsdbNode(final ConnectionInfo connectionInfo) {
375 return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
376 SouthboundUtils.createInstanceIdentifier(connectionInfo));
379 private boolean deleteOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
380 boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
381 SouthboundUtils.createInstanceIdentifier(connectionInfo));
382 Thread.sleep(OVSDB_UPDATE_TIMEOUT);
386 private Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
387 Assert.assertTrue(addOvsdbNode(connectionInfo));
388 Node node = getOvsdbNode(connectionInfo);
389 Assert.assertNotNull("Should find OVSDB node after connect", node);
390 LOG.info("Connected to {}", connectionInfoToString(connectionInfo));
394 private boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
395 Assert.assertTrue(deleteOvsdbNode(connectionInfo));
396 Node node = getOvsdbNode(connectionInfo);
397 Assert.assertNull("Should not find OVSDB node after disconnect", node);
398 //Assume.assumeNotNull(node); // Using assumeNotNull because there is no assumeNull
399 LOG.info("Disconnected from {}", connectionInfoToString(connectionInfo));
403 private String getControllerIPAddress() {
404 String addressString = ConfigProperties.getProperty(this.getClass(), "ovsdb.controller.address");
405 if (addressString != null) {
407 if (InetAddress.getByName(addressString) != null) {
408 return addressString;
410 } catch (UnknownHostException e) {
411 LOG.error("Host {} is invalid", addressString);
415 addressString = ConfigProperties.getProperty(this.getClass(), "of.address");
416 if (addressString != null) {
418 if (InetAddress.getByName(addressString) != null) {
419 return addressString;
421 } catch (UnknownHostException e) {
422 LOG.error("Host {} is invalid", addressString);
429 private short getControllerOFPort() {
430 short openFlowPort = Constants.OPENFLOW_PORT;
431 String portString = ConfigProperties.getProperty(this.getClass(), "of.listenPort");
432 if (portString != null) {
434 openFlowPort = Short.parseShort(portString);
435 } catch (NumberFormatException e) {
436 LOG.warn("Invalid port:{}, use default({})", portString,
443 private List<String> getControllersFromOvsdbNode(Node node) {
444 List<String> controllersStr = new ArrayList<>();
446 String controllerIpStr = getControllerIPAddress();
447 if (controllerIpStr != null) {
448 // If codepath makes it here, the ip address to be used was explicitly provided.
449 // Being so, also fetch openflowPort provided via ConfigProperties.
450 controllersStr.add(Constants.OPENFLOW_CONNECTION_PROTOCOL
451 + ":" + controllerIpStr + ":" + getControllerOFPort());
453 // Check if ovsdb node has manager entries
454 OvsdbNodeAugmentation ovsdbNodeAugmentation = southbound.extractOvsdbNode(node);
455 if (ovsdbNodeAugmentation != null) {
456 List<ManagerEntry> managerEntries = ovsdbNodeAugmentation.getManagerEntry();
457 if (managerEntries != null && !managerEntries.isEmpty()) {
458 for (ManagerEntry managerEntry : managerEntries) {
459 if (managerEntry == null || managerEntry.getTarget() == null) {
462 String[] tokens = managerEntry.getTarget().getValue().split(":");
463 if (tokens.length == 3 && tokens[0].equalsIgnoreCase("tcp")) {
464 controllersStr.add(Constants.OPENFLOW_CONNECTION_PROTOCOL
465 + ":" + tokens[1] + ":" + getControllerOFPort());
466 } else if (tokens[0].equalsIgnoreCase("ptcp")) {
467 ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
468 if (connectionInfo != null && connectionInfo.getLocalIp() != null) {
469 controllerIpStr = String.valueOf(connectionInfo.getLocalIp().getValue());
470 controllersStr.add(Constants.OPENFLOW_CONNECTION_PROTOCOL
471 + ":" + controllerIpStr + ":" + Constants.OPENFLOW_PORT);
473 LOG.warn("Ovsdb Node does not contain connection info: {}", node);
476 LOG.trace("Skipping manager entry {} for node {}",
477 managerEntry.getTarget(), node.getNodeId().getValue());
481 LOG.warn("Ovsdb Node does not contain manager entries : {}", node);
486 if (controllersStr.isEmpty()) {
487 // Neither user provided ip nor ovsdb node has manager entries. Lets use local machine ip address.
488 LOG.debug("Use local machine ip address as a OpenFlow Controller ip address");
489 controllerIpStr = getLocalControllerHostIpAddress();
490 if (controllerIpStr != null) {
491 controllersStr.add(Constants.OPENFLOW_CONNECTION_PROTOCOL
492 + ":" + controllerIpStr + ":" + Constants.OPENFLOW_PORT);
496 if (controllersStr.isEmpty()) {
497 LOG.warn("Failed to determine OpenFlow controller ip address");
498 } else if (LOG.isDebugEnabled()) {
499 controllerIpStr = "";
500 for (String currControllerIpStr : controllersStr) {
501 controllerIpStr += " " + currControllerIpStr;
503 LOG.debug("Found {} OpenFlow Controller(s) :{}", controllersStr.size(), controllerIpStr);
506 return controllersStr;
509 private String getLocalControllerHostIpAddress() {
510 String ipaddress = null;
512 for (Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces();ifaces.hasMoreElements();){
513 NetworkInterface iface = ifaces.nextElement();
515 for (Enumeration<InetAddress> inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements();) {
516 InetAddress inetAddr = inetAddrs.nextElement();
517 if (!inetAddr.isLoopbackAddress() && inetAddr.isSiteLocalAddress()) {
518 ipaddress = inetAddr.getHostAddress();
523 }catch (Exception e){
524 LOG.warn("Exception while fetching local host ip address ", e);
529 private String getControllerTarget(Node ovsdbNode) {
530 return getControllersFromOvsdbNode(ovsdbNode).get(0);
534 public void testAddDeleteOvsdbNode() throws InterruptedException {
535 LOG.info("testAddDeleteOvsdbNode enter 3");
536 ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
537 connectOvsdbNode(connectionInfo);
538 ControllerEntry controllerEntry;
539 for (int i = 0; i < 10; i++) {
540 LOG.info("testAddDeleteOvsdbNode ({}): looking for controller", i);
541 Node ovsdbNode = getOvsdbNode(connectionInfo);
542 Assert.assertNotNull("ovsdb node not found", ovsdbNode);
543 String controllerTarget = getControllerTarget(ovsdbNode);
544 Assert.assertNotNull("Failed to get controller target", controllerTarget);
545 OvsdbBridgeAugmentation bridge = getBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME);
546 Assert.assertNotNull(bridge);
547 Assert.assertNotNull(bridge.getControllerEntry());
548 controllerEntry = bridge.getControllerEntry().iterator().next();
549 Assert.assertEquals(controllerTarget, controllerEntry.getTarget().getValue());
550 if (controllerEntry.isIsConnected()) {
551 Assert.assertTrue(controllerEntry.isIsConnected());
557 Assert.assertTrue(deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
559 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
564 public void testOpenVSwitchOtherConfig() throws InterruptedException {
565 ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
566 Node ovsdbNode = connectOvsdbNode(connectionInfo);
567 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
568 Assert.assertNotNull(ovsdbNodeAugmentation);
569 List<OpenvswitchOtherConfigs> otherConfigsList = ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
570 if (otherConfigsList != null) {
571 for (OpenvswitchOtherConfigs otherConfig : otherConfigsList) {
572 if (otherConfig.getOtherConfigKey().equals("local_ip")) {
573 LOG.info("local_ip: {}", otherConfig.getOtherConfigValue());
576 LOG.info("other_config {}:{}", otherConfig.getOtherConfigKey(), otherConfig.getOtherConfigValue());
580 LOG.info("other_config is not present");
582 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
585 private OvsdbTerminationPointAugmentationBuilder createGenericOvsdbTerminationPointAugmentationBuilder() {
586 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointAugmentationBuilder =
587 new OvsdbTerminationPointAugmentationBuilder();
588 ovsdbTerminationPointAugmentationBuilder.setInterfaceType(
589 new InterfaceTypeEntryBuilder()
591 SouthboundMapper.createInterfaceType("internal"))
592 .build().getInterfaceType());
593 return ovsdbTerminationPointAugmentationBuilder;
596 private boolean addTerminationPoint(final NodeId bridgeNodeId, final String portName,
597 final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointAugmentationBuilder)
598 throws InterruptedException {
600 InstanceIdentifier<Node> portIid = SouthboundMapper.createInstanceIdentifier(bridgeNodeId);
601 NodeBuilder portNodeBuilder = new NodeBuilder();
602 NodeId portNodeId = SouthboundMapper.createManagedNodeId(portIid);
603 portNodeBuilder.setNodeId(portNodeId);
604 TerminationPointBuilder entry = new TerminationPointBuilder();
605 entry.setKey(new TerminationPointKey(new TpId(portName)));
606 entry.addAugmentation(
607 OvsdbTerminationPointAugmentation.class,
608 ovsdbTerminationPointAugmentationBuilder.build());
609 portNodeBuilder.setTerminationPoint(Lists.newArrayList(entry.build()));
610 boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
611 portIid, portNodeBuilder.build());
612 Thread.sleep(OVSDB_UPDATE_TIMEOUT);
617 * Extract the <code>store</code> type data store contents for the particular bridge identified by
618 * <code>bridgeName</code>.
620 * @param connectionInfo The connection information.
621 * @param bridgeName The bridge name.
622 * @param store defined by the <code>LogicalDatastoreType</code> enumeration
623 * @return <code>store</code> type data store contents
625 private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
626 LogicalDatastoreType store) {
627 Node bridgeNode = getBridgeNode(connectionInfo, bridgeName, store);
628 Assert.assertNotNull(bridgeNode);
629 OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
630 Assert.assertNotNull(ovsdbBridgeAugmentation);
631 return ovsdbBridgeAugmentation;
635 * extract the <code>LogicalDataStoreType.OPERATIONAL</code> type data store contents for the particular bridge
636 * identified by <code>bridgeName</code>
638 * @param connectionInfo The connection information.
639 * @param bridgeName The bridge name.
640 * @see <code>NetvirtIT.getBridge(ConnectionInfo, String, LogicalDatastoreType)</code>
641 * @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
643 private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
644 return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
648 * Extract the node contents from <code>store</code> type data store for the
649 * bridge identified by <code>bridgeName</code>
651 * @param connectionInfo The connection information.
652 * @param bridgeName The bridge name.
653 * @param store defined by the <code>LogicalDatastoreType</code> enumeration
654 * @return <code>store</code> type data store contents
656 private Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
657 InstanceIdentifier<Node> bridgeIid =
658 SouthboundUtils.createInstanceIdentifier(connectionInfo,
659 new OvsdbBridgeName(bridgeName));
660 return mdsalUtils.read(store, bridgeIid);
663 private boolean deleteBridge(final ConnectionInfo connectionInfo, final String bridgeName)
664 throws InterruptedException {
666 boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
667 SouthboundUtils.createInstanceIdentifier(connectionInfo,
668 new OvsdbBridgeName(bridgeName)));
669 Thread.sleep(OVSDB_UPDATE_TIMEOUT);
673 private InstanceIdentifier<Node> getTpIid(ConnectionInfo connectionInfo, OvsdbBridgeAugmentation bridge) {
674 return SouthboundUtils.createInstanceIdentifier(connectionInfo,
675 bridge.getBridgeName());
678 private void netVirtAddPort(ConnectionInfo connectionInfo) throws InterruptedException {
679 OvsdbBridgeAugmentation bridge = getBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME);
680 Assert.assertNotNull(bridge);
681 NodeId nodeId = SouthboundMapper.createManagedNodeId(SouthboundUtils.createInstanceIdentifier(
682 connectionInfo, bridge.getBridgeName()));
683 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
684 createGenericOvsdbTerminationPointAugmentationBuilder();
685 String portName = NetvirtITConstants.PORT_NAME;
686 ovsdbTerminationBuilder.setName(portName);
687 Assert.assertTrue(addTerminationPoint(nodeId, portName, ovsdbTerminationBuilder));
688 InstanceIdentifier<Node> terminationPointIid = getTpIid(connectionInfo, bridge);
689 Node terminationPointNode = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, terminationPointIid);
690 Assert.assertNotNull(terminationPointNode);
694 * Test for basic southbound events to netvirt.
695 * <pre>The test will:
696 * - connect to an OVSDB node and verify it is added to operational
697 * - then verify that br-int was created on the node and stored in operational
698 * - a port is then added to the bridge to verify that it is ignored by netvirt
699 * - remove the bridge
700 * - remove the node and verify it is not in operational
702 * @throws InterruptedException
705 public void testNetVirt() throws InterruptedException {
706 LOG.info("testNetVirt: starting test 2");
707 ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
708 Node ovsdbNode = connectOvsdbNode(connectionInfo);
709 LOG.info("testNetVirt: should be connected");
712 LOG.info("testNetVirt: should really be connected after sleep");
713 // Verify the pipeline flows were installed
714 PipelineOrchestrator pipelineOrchestrator =
715 (PipelineOrchestrator) ServiceHelper.getGlobalInstance(PipelineOrchestrator.class, this);
716 assertNotNull("Could not find PipelineOrchestrator Service", pipelineOrchestrator);
717 Node bridgeNode = southbound.getBridgeNode(ovsdbNode, NetvirtITConstants.INTEGRATION_BRIDGE_NAME);
718 assertNotNull("bridge " + NetvirtITConstants.INTEGRATION_BRIDGE_NAME + " was not found", bridgeNode);
719 LOG.info("testNetVirt: bridgeNode: {}", bridgeNode);
720 long datapathId = southbound.getDataPathId(bridgeNode);
721 assertNotEquals("datapathId was not found", datapathId, 0);
723 //TODO add check for controller connection
724 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder =
725 FlowUtils.createNodeBuilder(datapathId);
727 List<Service> staticPipeline = pipelineOrchestrator.getStaticPipeline();
728 List<Service> staticPipelineFound = Lists.newArrayList();
729 for (Service service : pipelineOrchestrator.getServiceRegistry().keySet()) {
730 if (staticPipeline.contains(service)) {
731 staticPipelineFound.add(service);
733 FlowBuilder flowBuilder = FlowUtils.getPipelineFlow(service.getTable(), (short)0);
734 Flow flow = getFlow(flowBuilder, nodeBuilder, LogicalDatastoreType.CONFIGURATION);
735 assertNotNull("Could not find flow in config", flow);
737 flow = getFlow(flowBuilder, nodeBuilder, LogicalDatastoreType.OPERATIONAL);
738 assertNotNull("Could not find flow in operational", flow);
740 assertEquals("did not find all expected flows in static pipeline",
741 staticPipeline.size(), staticPipelineFound.size());
743 netVirtAddPort(connectionInfo);
745 Assert.assertTrue(deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
747 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
752 public void testNetVirt2() throws InterruptedException {
758 public void testReadOvsdbTopologyNodes() throws InterruptedException {
760 List<Node> ovsdbNodes = southbound.readOvsdbTopologyNodes();
761 for (Node node : ovsdbNodes) {
762 LOG.info(">>>>> node: {}", node);
767 public void testNetVirtFixedSG() throws InterruptedException {
768 final Version minSGOvsVersion = Version.fromString("1.10.2");
770 ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
771 assertNotNull("connection failed", southboundUtils.connectOvsdbNode(connectionInfo));
772 Node ovsdbNode = connectOvsdbNode(connectionInfo);
773 assertNotNull("node is not connected", ovsdbNode);
775 // Verify the minimum version required for this test
776 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
777 Assert.assertNotNull(ovsdbNodeAugmentation);
778 assertNotNull(ovsdbNodeAugmentation.getOvsVersion());
779 String ovsVersion = ovsdbNodeAugmentation.getOvsVersion();
780 Version version = Version.fromString(ovsVersion);
781 if (version.compareTo(minSGOvsVersion) < 0) {
782 LOG.warn("{} minimum version is required", minSGOvsVersion);
783 Assert.assertTrue(deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
785 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
790 Node bridgeNode = southbound.getBridgeNode(ovsdbNode, NetvirtITConstants.INTEGRATION_BRIDGE_NAME);
791 assertNotNull("bridge " + NetvirtITConstants.INTEGRATION_BRIDGE_NAME + " was not found", bridgeNode);
792 long datapathId = southbound.getDataPathId(bridgeNode);
793 assertNotEquals("datapathId was not found", datapathId, 0);
795 NeutronNetwork nn = createNeutronNetwork(NETWORK_ID, TENANT_ID,NetworkHandler.NETWORK_TYPE_VXLAN, "100");
796 NeutronSubnet ns = createNeutronSubnet(SUBNET_ID, TENANT_ID, NETWORK_ID, "10.0.0.0/24");
797 NeutronPort nport = createNeutronPort(NETWORK_ID, SUBNET_ID, PORT1_ID, "compute", "10.0.0.10", "f6:00:00:0f:00:01");
798 NeutronPort dhcp = createNeutronPort(NETWORK_ID, SUBNET_ID, DHCPPORT_ID, "dhcp", "10.0.0.1", "f6:00:00:0f:00:02");
801 Map<String, String> externalIds = Maps.newHashMap();
802 externalIds.put("attached-mac", "f6:00:00:0f:00:01");
803 externalIds.put("iface-id", PORT1_ID);
804 southboundUtils.addTerminationPoint(bridgeNode, SDPLNAME, "internal", null, externalIds, 3L);
805 southboundUtils.addTerminationPoint(bridgeNode, "vm1", "internal", null, null, 0L);
806 southboundUtils.addTerminationPoint(bridgeNode, "vm2", "internal", null, null, 0L);
807 Map<String, String> options = Maps.newHashMap();
808 options.put("key", "flow");
809 options.put("remote_ip", "192.168.120.32");
810 southboundUtils.addTerminationPoint(bridgeNode, "vx", "vxlan", options, null, 4L);
813 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder =
814 FlowUtils.createNodeBuilder(datapathId);
815 MatchBuilder matchBuilder1 = new MatchBuilder();
816 matchBuilder1 = MatchUtils.createDhcpMatch(matchBuilder1, 68, 67);
817 String flowId1 = "Egress_DHCP_Client" + "_Permit_";
818 FlowBuilder flowBuilder1 = initFlowBuilder(matchBuilder1, flowId1, (short)40);
819 Flow flow1 = getFlow(flowBuilder1, nodeBuilder, LogicalDatastoreType.CONFIGURATION);
820 assertNotNull("EgressSG : Could not find flow in configuration ", flow1);
821 flow1 = getFlow(flowBuilder1, nodeBuilder, LogicalDatastoreType.OPERATIONAL);
822 assertNotNull("EgressSG Operational : Could not find flow in config", flow1);
824 testDefaultsSG(nport, datapathId, nn);
826 Assert.assertTrue(deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
828 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
831 private void testDefaultsSG(NeutronPort nport, long datapathId, NeutronNetwork nn)
832 throws InterruptedException {
833 INeutronSecurityGroupCRUD ineutronSecurityGroupCRUD =
834 (INeutronSecurityGroupCRUD) ServiceHelper.getGlobalInstance(INeutronSecurityGroupCRUD.class, this);
835 assertNotNull("Could not find ineutronSecurityGroupCRUD Service", ineutronSecurityGroupCRUD);
836 INeutronSecurityRuleCRUD ineutronSecurityRuleCRUD =
837 (INeutronSecurityRuleCRUD) ServiceHelper.getGlobalInstance(INeutronSecurityRuleCRUD.class, this);
838 assertNotNull("Could not find ineutronSecurityRuleCRUD Service", ineutronSecurityRuleCRUD);
840 NeutronSecurityGroup neutronSG = new NeutronSecurityGroup();
841 neutronSG.setSecurityGroupDescription("testig defaultSG-IT");
842 neutronSG.setSecurityGroupName("DefaultSG");
843 neutronSG.setSecurityGroupUUID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
844 neutronSG.setTenantID(TENANT_ID);
846 List<NeutronSecurityRule> nsrs = new ArrayList<>();
847 NeutronSecurityRule nsrIN = new NeutronSecurityRule();
848 nsrIN.setSecurityRemoteGroupID(null);
849 nsrIN.setSecurityRuleDirection("ingress");
850 nsrIN.setSecurityRuleEthertype("IPv4");
851 nsrIN.setSecurityRuleGroupID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
852 nsrIN.setSecurityRuleProtocol("TCP");
853 nsrIN.setSecurityRuleRemoteIpPrefix("10.0.0.0/24");
854 nsrIN.setSecurityRuleUUID("823faaf7-175d-4f01-a271-0bf56fb1e7e6");
855 nsrIN.setTenantID(TENANT_ID);
857 NeutronSecurityRule nsrEG = new NeutronSecurityRule();
858 nsrEG.setSecurityRemoteGroupID(null);
859 nsrEG.setSecurityRuleDirection("egress");
860 nsrEG.setSecurityRuleEthertype("IPv4");
861 nsrEG.setSecurityRuleGroupID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
862 nsrEG.setSecurityRuleProtocol("TCP");
863 nsrEG.setSecurityRuleRemoteIpPrefix("10.0.0.0/24");
864 nsrEG.setSecurityRuleUUID("823faaf7-175d-4f01-a271-0bf56fb1e7e1");
865 nsrEG.setTenantID(TENANT_ID);
870 neutronSG.setSecurityRules(nsrs);
871 ineutronSecurityRuleCRUD.addNeutronSecurityRule(nsrIN);
872 ineutronSecurityRuleCRUD.addNeutronSecurityRule(nsrEG);
873 ineutronSecurityGroupCRUD.add(neutronSG);
875 List<NeutronSecurityGroup> sgs = new ArrayList<>();
877 nport.setSecurityGroups(sgs);
879 INeutronPortCRUD iNeutronPortCRUD =
880 (INeutronPortCRUD) ServiceHelper.getGlobalInstance(INeutronPortCRUD.class, this);
881 iNeutronPortCRUD.update(PORT1_ID, nport);
884 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilderEg =
885 FlowUtils.createNodeBuilder(datapathId);
886 MatchBuilder matchBuilderEg = new MatchBuilder();
887 matchBuilderEg = MatchUtils.createEtherMatchWithType(matchBuilderEg, null, nport.getMacAddress());
888 String flowIdEg = "Egress_IP" + nn.getProviderSegmentationID() + "_" + nport.getMacAddress() + "_Permit_";
889 FlowBuilder flowBuilderEg = initFlowBuilder(matchBuilderEg, flowIdEg, (short)40);
890 Flow flowEg = getFlow(flowBuilderEg, nodeBuilderEg, LogicalDatastoreType.CONFIGURATION);
891 assertNotNull("EgressSG : Could not find flow in configuration ", flowEg);
892 flowEg = getFlow(flowBuilderEg, nodeBuilderEg, LogicalDatastoreType.OPERATIONAL);
893 assertNotNull("EgressSG Operational : Could not find flow in config", flowEg);
895 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilderIng =
896 FlowUtils.createNodeBuilder(datapathId);
897 MatchBuilder matchBuilderIng = new MatchBuilder();
898 matchBuilderIng = MatchUtils.createEtherMatchWithType(matchBuilderIng,null, nport.getMacAddress());
899 String flowIdIng = "Ingress_IP" + nn.getProviderSegmentationID() + "_" + nport.getMacAddress() + "_Permit_";
900 FlowBuilder flowBuilderIng = initFlowBuilder(matchBuilderIng, flowIdIng, (short)90);
901 Flow flowIng = getFlow(flowBuilderIng, nodeBuilderIng, LogicalDatastoreType.CONFIGURATION);
902 assertNotNull("IngressSG : Could not find flow in configuration ", flowIng);
903 flowIng = getFlow(flowBuilderIng, nodeBuilderIng, LogicalDatastoreType.OPERATIONAL);
904 assertNotNull("IngressSG Operational : Could not find flow in config", flowIng);
907 private NeutronPort createNeutronPort(String networkId, String subnetId,
908 String id, String owner, String ipaddr, String mac) {
909 INeutronPortCRUD iNeutronPortCRUD =
910 (INeutronPortCRUD) ServiceHelper.getGlobalInstance(INeutronPortCRUD.class, this);
911 NeutronPort np = new NeutronPort();
914 np.setDeviceOwner(owner);
915 np.setMacAddress(mac);
916 np.setNetworkUUID(networkId);
917 List<org.opendaylight.neutron.spi.Neutron_IPs> srcAddressList =
919 org.opendaylight.neutron.spi.Neutron_IPs nip = new org.opendaylight.neutron.spi.Neutron_IPs();
920 nip.setIpAddress(ipaddr);
921 nip.setSubnetUUID(subnetId);
922 srcAddressList.add(nip);
923 np.setFixedIPs(srcAddressList);
924 List<NeutronSecurityGroup> nsgs = new ArrayList<>();
925 np.setSecurityGroups(nsgs);
926 iNeutronPortCRUD.add(np);
930 private NeutronSubnet createNeutronSubnet(String subnetId, String tenantId,
931 String networkId, String cidr) {
932 INeutronSubnetCRUD iNeutronSubnetCRUD =
933 (INeutronSubnetCRUD) ServiceHelper.getGlobalInstance(INeutronSubnetCRUD.class, this);
934 NeutronSubnet ns = new NeutronSubnet();
938 ns.setNetworkUUID(networkId);
939 ns.setTenantID(tenantId);
940 iNeutronSubnetCRUD.add(ns);
944 private NeutronNetwork createNeutronNetwork(String uuid, String tenantID, String networkTypeVxlan, String segId) {
945 INeutronNetworkCRUD iNeutronNetworkCRUD =
946 (INeutronNetworkCRUD) ServiceHelper.getGlobalInstance(INeutronNetworkCRUD.class, this);
947 NeutronNetwork nn = new NeutronNetwork();
950 nn.setTenantID(tenantID);
951 nn.setProviderNetworkType(networkTypeVxlan);
952 nn.setProviderSegmentationID(segId);
953 iNeutronNetworkCRUD.addNetwork(nn);
957 private FlowBuilder initFlowBuilder(MatchBuilder matchBuilder, String flowId, short tableId) {
958 FlowBuilder flowBuilder = new FlowBuilder();
959 flowBuilder.setMatch(matchBuilder.build());
960 flowBuilder.setId(new FlowId(flowId));
961 flowBuilder.setFlowName(flowId);
962 FlowKey key = new FlowKey(new FlowId(flowId));
963 flowBuilder.setStrict(true);
964 flowBuilder.setTableId(tableId);
965 flowBuilder.setKey(key);
969 private Flow getFlow (
970 FlowBuilder flowBuilder,
971 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder,
972 LogicalDatastoreType store)
973 throws InterruptedException {
976 for (int i = 0; i < 10; i++) {
977 LOG.info("getFlow {}-{}: looking for flowBuilder: {}, nodeBuilder: {}",
978 i, store, flowBuilder.build(), nodeBuilder.build());
979 flow = FlowUtils.getFlow(flowBuilder, nodeBuilder, dataBroker.newReadOnlyTransaction(), store);
981 LOG.info("getFlow: found flow({}): {}", store, flow);