2 * Copyright (c) 2015 - 2016 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.netvirt.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.ops4j.pax.exam.CoreOptions.composite;
16 import static org.ops4j.pax.exam.CoreOptions.maven;
17 import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
18 import static org.ops4j.pax.exam.CoreOptions.propagateSystemProperties;
19 import static org.ops4j.pax.exam.CoreOptions.vmOption;
20 import static org.ops4j.pax.exam.CoreOptions.wrappedBundle;
21 import static org.ops4j.pax.exam.MavenUtils.asInProject;
22 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.configureConsole;
23 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.editConfigurationFilePut;
24 import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;
26 import com.google.common.collect.Lists;
27 import com.google.common.collect.Maps;
29 import java.util.ArrayList;
30 import java.util.List;
32 import java.util.Properties;
33 import java.util.concurrent.atomic.AtomicBoolean;
35 import org.junit.Assert;
36 import org.junit.Before;
37 import org.junit.Ignore;
38 import org.junit.Test;
39 import org.junit.runner.RunWith;
40 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
41 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
42 import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
43 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
44 import org.opendaylight.neutron.spi.INeutronPortCRUD;
45 import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
46 import org.opendaylight.neutron.spi.INeutronSecurityRuleCRUD;
47 import org.opendaylight.neutron.spi.NeutronPort;
48 import org.opendaylight.neutron.spi.NeutronSecurityGroup;
49 import org.opendaylight.neutron.spi.NeutronSecurityRule;
50 import org.opendaylight.neutron.spi.NeutronNetwork;
51 import org.opendaylight.neutron.spi.NeutronSubnet;
52 import org.opendaylight.ovsdb.lib.notation.Version;
53 import org.opendaylight.netvirt.openstack.netvirt.NetworkHandler;
54 import org.opendaylight.netvirt.openstack.netvirt.api.Southbound;
55 import org.opendaylight.netvirt.openstack.netvirt.providers.NetvirtProvidersProvider;
56 import org.opendaylight.netvirt.openstack.netvirt.providers.openflow13.PipelineOrchestrator;
57 import org.opendaylight.netvirt.openstack.netvirt.providers.openflow13.Service;
58 import org.opendaylight.netvirt.utils.it.utils.ItUtils;
59 import org.opendaylight.netvirt.utils.it.utils.NodeInfo;
60 import org.opendaylight.netvirt.utils.mdsal.openflow.FlowUtils;
61 import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
62 import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
63 import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
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.yangtools.yang.binding.InstanceIdentifier;
76 import org.ops4j.pax.exam.Configuration;
77 import org.ops4j.pax.exam.Option;
78 import org.ops4j.pax.exam.junit.PaxExam;
79 import org.ops4j.pax.exam.karaf.options.LogLevelOption;
80 import org.ops4j.pax.exam.options.MavenUrlReference;
81 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
82 import org.ops4j.pax.exam.spi.reactors.PerClass;
83 import org.slf4j.Logger;
84 import org.slf4j.LoggerFactory;
87 * Integration tests for netvirt
89 * @author Sam Hague (shague@redhat.com)
91 @RunWith(PaxExam.class)
92 @ExamReactorStrategy(PerClass.class)
93 public class NetvirtIT extends AbstractMdsalTestBase {
94 private static final Logger LOG = LoggerFactory.getLogger(NetvirtIT.class);
95 private static DataBroker dataBroker = null;
96 private static ItUtils itUtils;
97 private static String addressStr;
98 private static String portStr;
99 private static String connectionType;
100 private static String controllerStr;
101 private static AtomicBoolean setup = new AtomicBoolean(false);
102 private static MdsalUtils mdsalUtils = null;
103 private static Southbound southbound = null;
104 private static PipelineOrchestrator pipelineOrchestrator = null;
105 private static SouthboundUtils southboundUtils;
106 private static NeutronUtils neutronUtils = new NeutronUtils();
107 private static final String NETVIRT_TOPOLOGY_ID = "netvirt:1";
110 public String getModuleName() {
111 return "netvirt-providers-impl";
115 public String getInstanceName() {
116 return "netvirt-providers-default";
120 public MavenUrlReference getFeatureRepo() {
122 .groupId("org.opendaylight.netvirt")
123 .artifactId("features-netvirt")
124 .classifier("features")
126 .versionAsInProject();
130 public String getFeatureName() {
131 return "odl-ovsdb-openstack-it";
136 public Option[] config() {
137 Option[] parentOptions = super.config();
138 Option[] propertiesOptions = getPropertiesOptions();
139 Option[] otherOptions = getOtherOptions();
140 Option[] options = new Option[parentOptions.length + propertiesOptions.length + otherOptions.length];
141 System.arraycopy(parentOptions, 0, options, 0, parentOptions.length);
142 System.arraycopy(propertiesOptions, 0, options, parentOptions.length, propertiesOptions.length);
143 System.arraycopy(otherOptions, 0, options, parentOptions.length + propertiesOptions.length,
144 otherOptions.length);
148 private Option[] getOtherOptions() {
149 return new Option[] {
151 mavenBundle("org.opendaylight.netvirt", "utils.mdsal-openflow")
152 .version(asInProject())
155 mavenBundle("org.opendaylight.netvirt", "utils.config")
156 .version(asInProject())
158 configureConsole().startLocalConsole(),
159 vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
164 public Option[] getPropertiesOptions() {
165 return new Option[] {
166 propagateSystemProperties(NetvirtITConstants.SERVER_IPADDRESS,
167 NetvirtITConstants.SERVER_PORT, NetvirtITConstants.CONNECTION_TYPE,
168 NetvirtITConstants.CONTROLLER_IPADDRESS,
169 NetvirtITConstants.USERSPACE_ENABLED)
174 public Option getLoggingOption() {
176 //editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
177 // "log4j.logger.org.opendaylight.controller",
178 // LogLevelOption.LogLevel.TRACE.name()),
179 editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
180 "log4j.logger.org.opendaylight.ovsdb",
181 LogLevelOption.LogLevel.TRACE.name()),
182 editConfigurationFilePut(ORG_OPS4J_PAX_LOGGING_CFG,
183 logConfiguration(NetvirtIT.class),
184 LogLevelOption.LogLevel.INFO.name()),
185 editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
186 "log4j.logger.org.opendaylight.ovsdb.lib",
187 LogLevelOption.LogLevel.INFO.name()),
188 editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
189 "log4j.logger.org.opendaylight.openflowjava",
190 LogLevelOption.LogLevel.INFO.name()),
191 editConfigurationFilePut(NetvirtITConstants.ORG_OPS4J_PAX_LOGGING_CFG,
192 "log4j.logger.org.opendaylight.openflowplugin",
193 LogLevelOption.LogLevel.INFO.name()),
194 super.getLoggingOption());
197 protected String usage() {
198 return "Integration Test needs a valid connection configuration as follows :\n"
199 + "active connection : mvn -Dovsdbserver.ipaddress=x.x.x.x -Dovsdbserver.port=yyyy verify\n"
200 + "passive connection : mvn -Dovsdbserver.connection=passive verify\n";
203 private void getProperties() {
204 Properties props = System.getProperties();
205 addressStr = props.getProperty(NetvirtITConstants.SERVER_IPADDRESS);
206 portStr = props.getProperty(NetvirtITConstants.SERVER_PORT, NetvirtITConstants.DEFAULT_SERVER_PORT);
207 connectionType = props.getProperty(NetvirtITConstants.CONNECTION_TYPE, "active");
208 controllerStr = props.getProperty(NetvirtITConstants.CONTROLLER_IPADDRESS, "0.0.0.0");
209 String userSpaceEnabled = props.getProperty(NetvirtITConstants.USERSPACE_ENABLED, "no");
210 LOG.info("setUp: Using the following properties: mode= {}, ip:port= {}:{}, controller ip: {}, " +
211 "userspace.enabled: {}",
212 connectionType, addressStr, portStr, controllerStr, userSpaceEnabled);
213 if (connectionType.equalsIgnoreCase(NetvirtITConstants.CONNECTION_TYPE_ACTIVE)) {
214 if (addressStr == null) {
222 public void setup() throws InterruptedException {
224 LOG.info("Skipping setUp, already initialized");
230 } catch (Exception e) {
231 LOG.warn("Failed to setup test", e);
232 fail("Failed to setup test: " + e);
237 if (connectionType.equalsIgnoreCase(NetvirtITConstants.CONNECTION_TYPE_ACTIVE)) {
238 if (addressStr == null) {
243 dataBroker = getDatabroker(getProviderContext());
244 itUtils = new ItUtils(dataBroker);
245 mdsalUtils = new MdsalUtils(dataBroker);
246 assertNotNull("mdsalUtils should not be null", mdsalUtils);
247 assertTrue("Did not find " + NETVIRT_TOPOLOGY_ID, getNetvirtTopology());
248 southbound = (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
249 assertNotNull("southbound should not be null", southbound);
250 southboundUtils = new SouthboundUtils(mdsalUtils);
251 pipelineOrchestrator =
252 (PipelineOrchestrator) ServiceHelper.getGlobalInstance(PipelineOrchestrator.class, this);
253 assertNotNull("pipelineOrchestrator should not be null", pipelineOrchestrator);
257 private BindingAwareBroker.ProviderContext getProviderContext() {
258 BindingAwareBroker.ProviderContext providerContext = null;
259 for (int i=0; i < 60; i++) {
260 providerContext = getSession();
261 if (providerContext != null) {
266 } catch (InterruptedException e) {
267 LOG.warn("Interrupted while waiting for provider context", e);
271 assertNotNull("providercontext should not be null", providerContext);
272 /* One more second to let the provider finish initialization */
275 } catch (InterruptedException e) {
276 LOG.warn("Interrupted while waiting for other provider", e);
278 return providerContext;
281 private DataBroker getDatabroker(BindingAwareBroker.ProviderContext providerContext) {
282 DataBroker dataBroker = providerContext.getSALService(DataBroker.class);
283 assertNotNull("dataBroker should not be null", dataBroker);
287 private Boolean getNetvirtTopology() {
288 LOG.info("getNetvirtTopology: looking for {}...", NETVIRT_TOPOLOGY_ID);
289 Boolean found = false;
290 final TopologyId topologyId = new TopologyId(new Uri(NETVIRT_TOPOLOGY_ID));
291 InstanceIdentifier<Topology> path =
292 InstanceIdentifier.create(NetworkTopology.class).child(Topology.class, new TopologyKey(topologyId));
293 for (int i = 0; i < 60; i++) {
294 Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, path);
295 if (topology != null) {
296 LOG.info("getNetvirtTopology: found {}...", NETVIRT_TOPOLOGY_ID);
300 LOG.info("getNetvirtTopology: still looking ({})...", i);
303 } catch (InterruptedException e) {
304 LOG.warn("Interrupted while waiting for {}", NETVIRT_TOPOLOGY_ID, e);
312 * Test passive connection mode. The southbound starts in a listening mode waiting for connections on port
313 * 6640. This test will wait for incoming connections for {@link NetvirtITConstants#CONNECTION_INIT_TIMEOUT} ms.
315 * @throws InterruptedException
319 public void testPassiveNode() throws InterruptedException {
320 if (connectionType.equalsIgnoreCase(NetvirtITConstants.CONNECTION_TYPE_PASSIVE)) {
321 //Wait for CONNECTION_INIT_TIMEOUT for the Passive connection to be initiated by the ovsdb-server.
322 Thread.sleep(NetvirtITConstants.CONNECTION_INIT_TIMEOUT);
326 private Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
327 LOG.info("connectOvsdbNode enter");
328 Assert.assertTrue(southboundUtils.addOvsdbNode(connectionInfo));
329 Node node = southboundUtils.getOvsdbNode(connectionInfo);
330 Assert.assertNotNull("Should find OVSDB node after connect", node);
331 LOG.info("Connected to {}", SouthboundUtils.connectionInfoToString(connectionInfo));
335 private boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
336 LOG.info("disconnectOvsdbNode enter");
337 Assert.assertTrue(southboundUtils.deleteOvsdbNode(connectionInfo));
338 Node node = southboundUtils.getOvsdbNode(connectionInfo);
339 Assert.assertNull("Should not find OVSDB node after disconnect", node);
340 LOG.info("Disconnected from {}", SouthboundUtils.connectionInfoToString(connectionInfo));
344 // This is an extra test for local testing and testNetVirt covers this is more detail
347 public void testAddDeleteOvsdbNode() throws InterruptedException {
348 LOG.info("testAddDeleteOvsdbNode enter");
349 ConnectionInfo connectionInfo = SouthboundUtils.getConnectionInfo(addressStr, portStr);
350 Node ovsdbNode = connectOvsdbNode(connectionInfo);
351 assertNotNull("connection failed", ovsdbNode);
352 LOG.info("testNetVirt: should be connected: {}", ovsdbNode.getNodeId());
354 assertTrue("Controller " + SouthboundUtils.connectionInfoToString(connectionInfo)
355 + " is not connected", itUtils.isControllerConnected(connectionInfo));
357 Assert.assertTrue(southboundUtils.deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
359 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
360 LOG.info("testAddDeleteOvsdbNode exit");
363 // TODO add tests for when L3 is enabled and check for br-ex
365 // This is an extra test for local testing and testNetVirt covers this is more detail
368 public void testAddDeleteOvsdbNodeWithTableOffset() throws InterruptedException {
369 LOG.info("testAddDeleteOvsdbNodeWithTableOffset enter");
370 NetvirtProvidersProvider.setTableOffset((short)1);
371 ConnectionInfo connectionInfo = SouthboundUtils.getConnectionInfo(addressStr, portStr);
372 Node ovsdbNode = connectOvsdbNode(connectionInfo);
373 assertNotNull("connection failed", ovsdbNode);
374 LOG.info("testNetVirt: should be connected: {}", ovsdbNode.getNodeId());
376 assertTrue("Controller " + SouthboundUtils.connectionInfoToString(connectionInfo)
377 + " is not connected", itUtils.isControllerConnected(connectionInfo));
379 // Verify the pipeline flows were installed
380 Node bridgeNode = southbound.getBridgeNode(ovsdbNode, NetvirtITConstants.INTEGRATION_BRIDGE_NAME);
381 assertNotNull("bridge " + NetvirtITConstants.INTEGRATION_BRIDGE_NAME + " was not found", bridgeNode);
382 long datapathId = southbound.getDataPathId(bridgeNode);
383 String datapathIdString = southbound.getDatapathId(bridgeNode);
384 LOG.info("testNetVirt: bridgeNode: {}, datapathId: {} - {}", bridgeNode, datapathIdString, datapathId);
385 assertNotEquals("datapathId was not found", datapathId, 0);
387 List<Service> staticPipeline = pipelineOrchestrator.getStaticPipeline();
388 List<Service> staticPipelineFound = Lists.newArrayList();
389 for (Service service : pipelineOrchestrator.getServiceRegistry().keySet()) {
390 if (staticPipeline.contains(service)) {
391 staticPipelineFound.add(service);
393 String flowId = "DEFAULT_PIPELINE_FLOW_" + pipelineOrchestrator.getTable(service);
394 verifyFlow(datapathId, flowId, service);
396 assertEquals("did not find all expected flows in static pipeline",
397 staticPipeline.size(), staticPipelineFound.size());
399 String flowId = "TableOffset_" + pipelineOrchestrator.getTable(Service.CLASSIFIER);
400 verifyFlow(datapathId, flowId, Service.CLASSIFIER.getTable());
402 Assert.assertTrue(southboundUtils.deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
404 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
405 LOG.info("testAddDeleteOvsdbNodeWithTableOffset exit");
410 public void testOpenVSwitchOtherConfig() throws InterruptedException {
411 ConnectionInfo connectionInfo = SouthboundUtils.getConnectionInfo(addressStr, portStr);
412 Node ovsdbNode = connectOvsdbNode(connectionInfo);
413 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
414 Assert.assertNotNull(ovsdbNodeAugmentation);
415 List<OpenvswitchOtherConfigs> otherConfigsList = ovsdbNodeAugmentation.getOpenvswitchOtherConfigs();
416 if (otherConfigsList != null) {
417 for (OpenvswitchOtherConfigs otherConfig : otherConfigsList) {
418 if (otherConfig.getOtherConfigKey().equals("local_ip")) {
419 LOG.info("local_ip: {}", otherConfig.getOtherConfigValue());
422 LOG.info("other_config {}:{}", otherConfig.getOtherConfigKey(), otherConfig.getOtherConfigValue());
426 LOG.info("other_config is not present");
428 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
432 * Test for basic southbound events to netvirt.
433 * <pre>The test will:
434 * - connect to an OVSDB node and verify it is added to operational
435 * - then verify that br-int was created on the node and stored in operational
436 * - a port is then added to the bridge to verify that it is ignored by netvirt
437 * - remove the bridge
438 * - remove the node and verify it is not in operational
440 * @throws InterruptedException
443 public void testNetVirt() throws InterruptedException {
444 LOG.info("testNetVirt: starting test");
445 ConnectionInfo connectionInfo = SouthboundUtils.getConnectionInfo(addressStr, portStr);
446 NodeInfo nodeInfo = itUtils.createNodeInfo(connectionInfo, null);
448 LOG.info("testNetVirt: should be connected: {}", nodeInfo.ovsdbNode.getNodeId());
450 List<Service> staticPipeline = pipelineOrchestrator.getStaticPipeline();
451 List<Service> staticPipelineFound = Lists.newArrayList();
452 for (Service service : pipelineOrchestrator.getServiceRegistry().keySet()) {
453 if (staticPipeline.contains(service)) {
454 staticPipelineFound.add(service);
456 String flowId = "DEFAULT_PIPELINE_FLOW_" + pipelineOrchestrator.getTable(service);
457 verifyFlow(nodeInfo.datapathId, flowId, service);
459 assertEquals("did not find all expected flows in static pipeline",
460 staticPipeline.size(), staticPipelineFound.size());
462 southboundUtils.addTerminationPoint(nodeInfo.bridgeNode, NetvirtITConstants.PORT_NAME, "internal", null, null, 0L);
464 OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
465 southbound.getTerminationPointOfBridge(nodeInfo.bridgeNode, NetvirtITConstants.PORT_NAME);
466 Assert.assertNotNull("Did not find " + NetvirtITConstants.PORT_NAME, ovsdbTerminationPointAugmentation);
468 nodeInfo.disconnect();
472 public void testNetVirtFixedSG() throws InterruptedException {
473 final Version minSGOvsVersion = Version.fromString("1.10.2");
474 final String portName = "sg1";
475 final String networkId = "521e29d6-67b8-4b3c-8633-027d21195111";
476 final String tenantId = "521e29d6-67b8-4b3c-8633-027d21195100";
477 final String subnetId = "521e29d6-67b8-4b3c-8633-027d21195112";
478 final String portId = "521e29d6-67b8-4b3c-8633-027d21195113";
479 final String dhcpPortId ="521e29d6-67b8-4b3c-8633-027d21195115";
481 ConnectionInfo connectionInfo = SouthboundUtils.getConnectionInfo(addressStr, portStr);
482 NodeInfo nodeInfo = itUtils.createNodeInfo(connectionInfo, null);
484 LOG.info("testNetVirtFixedSG: should be connected: {}", nodeInfo.ovsdbNode.getNodeId());
486 // Verify the minimum version required for this test
487 OvsdbNodeAugmentation ovsdbNodeAugmentation = nodeInfo.ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
488 Assert.assertNotNull(ovsdbNodeAugmentation);
489 assertNotNull(ovsdbNodeAugmentation.getOvsVersion());
490 String ovsVersion = ovsdbNodeAugmentation.getOvsVersion();
491 Version version = Version.fromString(ovsVersion);
492 if (version.compareTo(minSGOvsVersion) < 0) {
493 LOG.warn("{} minimum version is required", minSGOvsVersion);
494 Assert.assertTrue(southboundUtils.deleteBridge(connectionInfo,
495 NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
497 Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
501 NeutronNetwork nn = neutronUtils.createNeutronNetwork(networkId, tenantId,
502 NetworkHandler.NETWORK_TYPE_VXLAN, "100");
503 NeutronSubnet ns = neutronUtils.createNeutronSubnet(subnetId, tenantId, networkId, "10.0.0.0/24");
504 NeutronPort nport = neutronUtils.createNeutronPort(networkId, subnetId, portId,
505 "compute", "10.0.0.10", "f6:00:00:0f:00:01");
506 NeutronPort dhcp = neutronUtils.createNeutronPort(networkId, subnetId, dhcpPortId,
507 "dhcp", "10.0.0.1", "f6:00:00:0f:00:02");
510 Map<String, String> externalIds = Maps.newHashMap();
511 externalIds.put("attached-mac", "f6:00:00:0f:00:01");
512 externalIds.put("iface-id", portId);
513 southboundUtils.addTerminationPoint(nodeInfo.bridgeNode, portName, "internal", null, externalIds, 3L);
514 southboundUtils.addTerminationPoint(nodeInfo.bridgeNode, "vm1", "internal", null, null, 0L);
515 southboundUtils.addTerminationPoint(nodeInfo.bridgeNode, "vm2", "internal", null, null, 0L);
516 Map<String, String> options = Maps.newHashMap();
517 options.put("key", "flow");
518 options.put("remote_ip", "192.168.120.32");
519 southboundUtils.addTerminationPoint(nodeInfo.bridgeNode, "vx", "vxlan", options, null, 4L);
522 String flowId = "Egress_DHCP_Client" + "_Permit_";
523 verifyFlow(nodeInfo.datapathId, flowId, Service.EGRESS_ACL);
525 testDefaultSG(nport, nodeInfo.datapathId, nn, tenantId, portId);
528 nodeInfo.disconnect();
531 private void testDefaultSG(NeutronPort nport, long datapathId, NeutronNetwork nn, String tenantId, String portId)
532 throws InterruptedException {
533 INeutronSecurityGroupCRUD ineutronSecurityGroupCRUD =
534 (INeutronSecurityGroupCRUD) ServiceHelper.getGlobalInstance(INeutronSecurityGroupCRUD.class, this);
535 assertNotNull("Could not find ineutronSecurityGroupCRUD Service", ineutronSecurityGroupCRUD);
536 INeutronSecurityRuleCRUD ineutronSecurityRuleCRUD =
537 (INeutronSecurityRuleCRUD) ServiceHelper.getGlobalInstance(INeutronSecurityRuleCRUD.class, this);
538 assertNotNull("Could not find ineutronSecurityRuleCRUD Service", ineutronSecurityRuleCRUD);
540 NeutronSecurityGroup neutronSG = new NeutronSecurityGroup();
541 neutronSG.setSecurityGroupDescription("testig defaultSG-IT");
542 neutronSG.setSecurityGroupName("DefaultSG");
543 neutronSG.setSecurityGroupUUID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
544 neutronSG.setTenantID(tenantId);
546 List<NeutronSecurityRule> nsrs = new ArrayList<>();
547 NeutronSecurityRule nsrIN = new NeutronSecurityRule();
548 nsrIN.setSecurityRemoteGroupID(null);
549 nsrIN.setSecurityRuleDirection("ingress");
550 nsrIN.setSecurityRuleEthertype("IPv4");
551 nsrIN.setSecurityRuleGroupID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
552 nsrIN.setSecurityRuleProtocol("TCP");
553 nsrIN.setSecurityRuleRemoteIpPrefix("10.0.0.0/24");
554 nsrIN.setSecurityRuleUUID("823faaf7-175d-4f01-a271-0bf56fb1e7e6");
555 nsrIN.setTenantID(tenantId);
557 NeutronSecurityRule nsrEG = new NeutronSecurityRule();
558 nsrEG.setSecurityRemoteGroupID(null);
559 nsrEG.setSecurityRuleDirection("egress");
560 nsrEG.setSecurityRuleEthertype("IPv4");
561 nsrEG.setSecurityRuleGroupID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
562 nsrEG.setSecurityRuleProtocol("TCP");
563 nsrEG.setSecurityRuleRemoteIpPrefix("10.0.0.0/24");
564 nsrEG.setSecurityRuleUUID("823faaf7-175d-4f01-a271-0bf56fb1e7e1");
565 nsrEG.setTenantID(tenantId);
570 neutronSG.setSecurityRules(nsrs);
571 ineutronSecurityRuleCRUD.addNeutronSecurityRule(nsrIN);
572 ineutronSecurityRuleCRUD.addNeutronSecurityRule(nsrEG);
573 ineutronSecurityGroupCRUD.add(neutronSG);
575 List<NeutronSecurityGroup> sgs = new ArrayList<>();
577 nport.setSecurityGroups(sgs);
579 INeutronPortCRUD iNeutronPortCRUD =
580 (INeutronPortCRUD) ServiceHelper.getGlobalInstance(INeutronPortCRUD.class, this);
581 iNeutronPortCRUD.update(portId, nport);
583 LOG.info("Neutron ports have been added");
585 String flowId = "Egress_IP" + nn.getProviderSegmentationID() + "_" + nport.getMacAddress() + "_Permit_";
586 verifyFlow(datapathId, flowId, Service.EGRESS_ACL);
588 flowId = "Ingress_IP" + nn.getProviderSegmentationID() + "_" + nport.getMacAddress() + "_Permit_";
589 verifyFlow(datapathId, flowId, Service.INGRESS_ACL);
592 private Flow getFlow (
593 FlowBuilder flowBuilder,
594 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder,
595 LogicalDatastoreType store) throws InterruptedException {
598 for (int i = 0; i < 10; i++) {
599 LOG.info("getFlow try {} from {}: looking for flow: {}, node: {}",
600 i, store, flowBuilder.build(), nodeBuilder.build());
601 flow = FlowUtils.getFlow(flowBuilder, nodeBuilder, dataBroker.newReadOnlyTransaction(), store);
603 LOG.info("getFlow try {} from {}: found flow: {}", i, store, flow);
611 private void verifyFlow(long datapathId, String flowId, short table) throws InterruptedException {
612 org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder =
613 FlowUtils.createNodeBuilder(datapathId);
614 FlowBuilder flowBuilder =
615 FlowUtils.initFlowBuilder(new FlowBuilder(), flowId, table);
616 Flow flow = getFlow(flowBuilder, nodeBuilder, LogicalDatastoreType.CONFIGURATION);
617 assertNotNull("Could not find flow in config: " + flowBuilder.build() + "--" + nodeBuilder.build(), flow);
618 flow = getFlow(flowBuilder, nodeBuilder, LogicalDatastoreType.OPERATIONAL);
619 assertNotNull("Could not find flow in operational: " + flowBuilder.build() + "--" + nodeBuilder.build(),
623 private void verifyFlow(long datapathId, String flowId, Service service) throws InterruptedException {
624 verifyFlow(datapathId, flowId, pipelineOrchestrator.getTable(service));