import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;
import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
+import java.util.Map;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicBoolean;
+
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.mdsal.it.base.AbstractMdsalTestBase;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.neutron.spi.INeutronPortCRUD;
+import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
+import org.opendaylight.neutron.spi.INeutronSecurityRuleCRUD;
+import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
+import org.opendaylight.neutron.spi.NeutronPort;
+import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
+import org.opendaylight.neutron.spi.NeutronSecurityGroup;
+import org.opendaylight.neutron.spi.NeutronSecurityRule;
+import org.opendaylight.neutron.spi.NeutronNetwork;
+import org.opendaylight.neutron.spi.NeutronSubnet;
+import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.PipelineOrchestrator;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
import org.opendaylight.ovsdb.utils.config.ConfigProperties;
import org.opendaylight.ovsdb.utils.mdsal.openflow.FlowUtils;
+import org.opendaylight.ovsdb.utils.mdsal.openflow.MatchUtils;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
-
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
private static AtomicBoolean setup = new AtomicBoolean(false);
private static MdsalUtils mdsalUtils = null;
private static Southbound southbound = null;
+ private static SouthboundUtils southboundUtils;
private static final String NETVIRT_TOPOLOGY_ID = "netvirt:1";
+ private static final String SDPLNAME = "sg1";
+ private static final String NETWORK_ID = "521e29d6-67b8-4b3c-8633-027d21195111";
+ private static final String TENANT_ID = "521e29d6-67b8-4b3c-8633-027d21195100";
+ private static final String SUBNET_ID = "521e29d6-67b8-4b3c-8633-027d21195112";
+ private static final String PORT1_ID = "521e29d6-67b8-4b3c-8633-027d21195113";
+ private static final String DHCPPORT_ID ="521e29d6-67b8-4b3c-8633-027d21195115";
@Override
public String getModuleName() {
assertTrue("Did not find " + NETVIRT_TOPOLOGY_ID, getNetvirtTopology());
southbound = (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
assertNotNull("southbound should not be null", southbound);
+ southboundUtils = new SouthboundUtils(mdsalUtils);
setup.set(true);
}
}
}
+ @Test
+ public void testNetVirtFixedSG() throws InterruptedException {
+ ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portStr);
+ assertNotNull("connection failed", southboundUtils.connectOvsdbNode(connectionInfo));
+ Node ovsdbNode = connectOvsdbNode(connectionInfo);
+ assertNotNull("node is not connected", ovsdbNode);
+
+ Thread.sleep(30000);
+ Node bridgeNode = southbound.getBridgeNode(ovsdbNode, NetvirtITConstants.INTEGRATION_BRIDGE_NAME);
+ assertNotNull("bridge " + NetvirtITConstants.INTEGRATION_BRIDGE_NAME + " was not found", bridgeNode);
+ long datapathId = southbound.getDataPathId(bridgeNode);
+ assertNotEquals("datapathId was not found", datapathId, 0);
+
+ NeutronNetwork nn = createNeutronNetwork(NETWORK_ID, TENANT_ID,NetworkHandler.NETWORK_TYPE_VXLAN, "100");
+ NeutronSubnet ns = createNeutronSubnet(SUBNET_ID, TENANT_ID, NETWORK_ID, "10.0.0.0/24");
+ NeutronPort nport = createNeutronPort(NETWORK_ID, SUBNET_ID, PORT1_ID, "compute", "10.0.0.10", "f6:00:00:0f:00:01");
+ NeutronPort dhcp = createNeutronPort(NETWORK_ID, SUBNET_ID, DHCPPORT_ID, "dhcp", "10.0.0.1", "f6:00:00:0f:00:02");
+
+ Thread.sleep(30000);
+ Map<String, String> externalIds = Maps.newHashMap();
+ externalIds.put("attached-mac", "f6:00:00:0f:00:01");
+ externalIds.put("iface-id", PORT1_ID);
+ southboundUtils.addTerminationPoint(bridgeNode, null, SDPLNAME, "internal", null, externalIds, new Long(3));
+ southboundUtils.addTerminationPoint(bridgeNode, null, "vm1", "internal", null, null, 0L);
+ southboundUtils.addTerminationPoint(bridgeNode, null, "vm2", "internal", null, null, 0L);
+ Map<String, String> options = Maps.newHashMap();
+ options.put("key", "flow");
+ options.put("remote_ip", "192.168.120.32");
+ southboundUtils.addTerminationPoint(bridgeNode, null, "vx", "vxlan", options, null, new Long(4));
+ Thread.sleep(1000);
+
+ org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder =
+ FlowUtils.createNodeBuilder(datapathId);
+ MatchBuilder matchBuilder1 = new MatchBuilder();
+ matchBuilder1 = MatchUtils.createDhcpMatch(matchBuilder1, 68, 67);
+ String flowId1 = "Egress_DHCP_Client" + "_Permit_";
+ FlowBuilder flowBuilder1 = initFlowBuilder(matchBuilder1, flowId1, (short)40);
+ Flow flow1 = getFlow(flowBuilder1, nodeBuilder, LogicalDatastoreType.CONFIGURATION);
+ assertNotNull("EgressSG : Could not find flow in configuration ", flow1);
+ flow1 = getFlow(flowBuilder1, nodeBuilder, LogicalDatastoreType.OPERATIONAL);
+ assertNotNull("EgressSG Operational : Could not find flow in config", flow1);
+
+ testDefaultsSG(nport, datapathId, nn);
+ Thread.sleep(30000);
+ Assert.assertTrue(deleteBridge(connectionInfo, NetvirtITConstants.INTEGRATION_BRIDGE_NAME));
+ Thread.sleep(10000);
+ Assert.assertTrue(disconnectOvsdbNode(connectionInfo));
+ }
+
+ private void testDefaultsSG(NeutronPort nport, long datapathId, NeutronNetwork nn)
+ throws InterruptedException {
+ INeutronSecurityGroupCRUD ineutronSecurityGroupCRUD =
+ (INeutronSecurityGroupCRUD) ServiceHelper.getGlobalInstance(INeutronSecurityGroupCRUD.class, this);
+ assertNotNull("Could not find ineutronSecurityGroupCRUD Service", ineutronSecurityGroupCRUD);
+ INeutronSecurityRuleCRUD ineutronSecurityRuleCRUD =
+ (INeutronSecurityRuleCRUD) ServiceHelper.getGlobalInstance(INeutronSecurityRuleCRUD.class, this);
+ assertNotNull("Could not find ineutronSecurityRuleCRUD Service", ineutronSecurityRuleCRUD);
+
+ NeutronSecurityGroup neutronSG = new NeutronSecurityGroup();
+ neutronSG.setSecurityGroupDescription("testig defaultSG-IT");
+ neutronSG.setSecurityGroupName("DefaultSG");
+ neutronSG.setSecurityGroupUUID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
+ neutronSG.setTenantID(TENANT_ID);
+
+ List<NeutronSecurityRule> nsrs = new ArrayList<NeutronSecurityRule>();
+ NeutronSecurityRule nsrIN = new NeutronSecurityRule();
+ nsrIN.setSecurityRemoteGroupID(null);
+ nsrIN.setSecurityRuleDirection("ingress");
+ nsrIN.setSecurityRuleEthertype("IPv4");
+ nsrIN.setSecurityRuleGroupID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
+ nsrIN.setSecurityRuleProtocol("TCP");
+ nsrIN.setSecurityRuleRemoteIpPrefix("10.0.0.0/24");
+ nsrIN.setSecurityRuleUUID("823faaf7-175d-4f01-a271-0bf56fb1e7e6");
+ nsrIN.setTenantID(TENANT_ID);
+
+ NeutronSecurityRule nsrEG = new NeutronSecurityRule();
+ nsrEG.setSecurityRemoteGroupID(null);
+ nsrEG.setSecurityRuleDirection("egress");
+ nsrEG.setSecurityRuleEthertype("IPv4");
+ nsrEG.setSecurityRuleGroupID("d3329053-bae5-4bf4-a2d1-7330f11ba5db");
+ nsrEG.setSecurityRuleProtocol("TCP");
+ nsrEG.setSecurityRuleRemoteIpPrefix("10.0.0.0/24");
+ nsrEG.setSecurityRuleUUID("823faaf7-175d-4f01-a271-0bf56fb1e7e1");
+ nsrEG.setTenantID(TENANT_ID);
+
+ nsrs.add(nsrIN);
+ nsrs.add(nsrEG);
+
+ neutronSG.setSecurityRules(nsrs);
+ ineutronSecurityRuleCRUD.addNeutronSecurityRule(nsrIN);
+ ineutronSecurityRuleCRUD.addNeutronSecurityRule(nsrEG);
+ ineutronSecurityGroupCRUD.add(neutronSG);
+
+ List<NeutronSecurityGroup> sgs = new ArrayList<NeutronSecurityGroup>();
+ sgs.add(neutronSG);
+ nport.setSecurityGroups(sgs);
+
+ INeutronPortCRUD iNeutronPortCRUD =
+ (INeutronPortCRUD) ServiceHelper.getGlobalInstance(INeutronPortCRUD.class, this);
+ iNeutronPortCRUD.update(PORT1_ID, nport);
+
+ Thread.sleep(20000);
+ org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilderEg =
+ FlowUtils.createNodeBuilder(datapathId);
+ MatchBuilder matchBuilderEg = new MatchBuilder();
+ matchBuilderEg = MatchUtils.createEtherMatchWithType(matchBuilderEg, null, nport.getMacAddress());
+ String flowIdEg = "Egress_IP" + nn.getProviderSegmentationID() + "_" + nport.getMacAddress() + "_Permit_";
+ FlowBuilder flowBuilderEg = initFlowBuilder(matchBuilderEg, flowIdEg, (short)40);
+ Flow flowEg = getFlow(flowBuilderEg, nodeBuilderEg, LogicalDatastoreType.CONFIGURATION);
+ assertNotNull("EgressSG : Could not find flow in configuration ", flowEg);
+ flowEg = getFlow(flowBuilderEg, nodeBuilderEg, LogicalDatastoreType.OPERATIONAL);
+ assertNotNull("EgressSG Operational : Could not find flow in config", flowEg);
+
+ org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilderIng =
+ FlowUtils.createNodeBuilder(datapathId);
+ MatchBuilder matchBuilderIng = new MatchBuilder();
+ matchBuilderIng = MatchUtils.createEtherMatchWithType(matchBuilderIng,null, nport.getMacAddress());
+ String flowIdIng = "Ingress_IP" + nn.getProviderSegmentationID() + "_" + nport.getMacAddress() + "_Permit_";
+ FlowBuilder flowBuilderIng = initFlowBuilder(matchBuilderIng, flowIdIng, (short)90);
+ Flow flowIng = getFlow(flowBuilderIng, nodeBuilderIng, LogicalDatastoreType.CONFIGURATION);
+ assertNotNull("IngressSG : Could not find flow in configuration ", flowIng);
+ flowEg = getFlow(flowBuilderIng, nodeBuilderIng, LogicalDatastoreType.OPERATIONAL);
+ assertNotNull("IngressSG Operational : Could not find flow in config", flowIng);
+
+ }
+
+ private NeutronPort createNeutronPort(String networkId, String subnetId,
+ String id, String owner, String ipaddr, String mac) {
+ INeutronPortCRUD iNeutronPortCRUD =
+ (INeutronPortCRUD) ServiceHelper.getGlobalInstance(INeutronPortCRUD.class, this);
+ NeutronPort np = new NeutronPort();
+ np.initDefaults();
+ np.setID(id);
+ np.setDeviceOwner(owner);
+ np.setMacAddress(mac);
+ np.setNetworkUUID(networkId);
+ List<org.opendaylight.neutron.spi.Neutron_IPs> srcAddressList =
+ new ArrayList<org.opendaylight.neutron.spi.Neutron_IPs>();
+ org.opendaylight.neutron.spi.Neutron_IPs nip = new org.opendaylight.neutron.spi.Neutron_IPs();
+ nip.setIpAddress(ipaddr);
+ nip.setSubnetUUID(subnetId);
+ srcAddressList.add(nip);
+ np.setFixedIPs(srcAddressList);
+ List<NeutronSecurityGroup> nsgs = new ArrayList<NeutronSecurityGroup>();
+ np.setSecurityGroups(nsgs);
+ iNeutronPortCRUD.add(np);
+ return np;
+ }
+
+ private NeutronSubnet createNeutronSubnet(String subnetId, String tenantId,
+ String networkId, String cidr) {
+ INeutronSubnetCRUD iNeutronSubnetCRUD =
+ (INeutronSubnetCRUD) ServiceHelper.getGlobalInstance(INeutronSubnetCRUD.class, this);
+ NeutronSubnet ns = new NeutronSubnet();
+ ns.setID(subnetId);
+ ns.setCidr(cidr);
+ ns.initDefaults();
+ ns.setNetworkUUID(networkId);
+ ns.setTenantID(tenantId);
+ iNeutronSubnetCRUD.add(ns);
+ return ns;
+ }
+
+ private NeutronNetwork createNeutronNetwork(String uuid, String tenantID, String networkTypeVxlan, String segId) {
+ INeutronNetworkCRUD iNeutronNetworkCRUD =
+ (INeutronNetworkCRUD) ServiceHelper.getGlobalInstance(INeutronNetworkCRUD.class, this);
+ NeutronNetwork nn = new NeutronNetwork();
+ nn.setID(uuid);
+ nn.initDefaults();
+ nn.setTenantID(tenantID);
+ nn.setProviderNetworkType(networkTypeVxlan);
+ nn.setProviderSegmentationID(segId);
+ iNeutronNetworkCRUD.addNetwork(nn);
+ return nn;
+ }
+
+ private FlowBuilder initFlowBuilder(MatchBuilder matchBuilder, String flowId, short tableId) {
+ FlowBuilder flowBuilder = new FlowBuilder();
+ flowBuilder.setMatch(matchBuilder.build());
+ flowBuilder.setId(new FlowId(flowId));
+ flowBuilder.setFlowName(flowId);
+ FlowKey key = new FlowKey(new FlowId(flowId));
+ flowBuilder.setStrict(true);
+ flowBuilder.setTableId(tableId);
+ flowBuilder.setKey(key);
+ return flowBuilder;
+ }
+
private Flow getFlow (
FlowBuilder flowBuilder,
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder,
--- /dev/null
+/*
+ * Copyright (c) 2015 Red Hat, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.ovsdb.openstack.netvirt.it;
+
+import com.google.common.collect.ImmutableBiMap;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+
+import java.util.List;
+import java.util.Map;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
+import org.opendaylight.ovsdb.southbound.SouthboundMapper;
+//import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SouthboundUtils {
+ private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtils.class);
+ private static final int OVSDB_UPDATE_TIMEOUT = 1000;
+ private static final String DEFAULT_OPENFLOW_PORT = "6653";
+ private static final String OPENFLOW_CONNECTION_PROTOCOL = "tcp";
+ private MdsalUtils mdsalUtils;
+ public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
+
+ public SouthboundUtils(MdsalUtils mdsalUtils) {
+ this.mdsalUtils = mdsalUtils;
+ }
+
+ public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP
+ = new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
+ .put("internal", InterfaceTypeInternal.class)
+ .put("vxlan", InterfaceTypeVxlan.class)
+ .put("patch", InterfaceTypePatch.class)
+ .put("system", InterfaceTypeSystem.class)
+ .put("tap", InterfaceTypeTap.class)
+ .put("geneve", InterfaceTypeGeneve.class)
+ .put("gre", InterfaceTypeGre.class)
+ .put("ipsec_gre", InterfaceTypeIpsecGre.class)
+ .put("gre64", InterfaceTypeGre64.class)
+ .put("ipsec_gre64", InterfaceTypeIpsecGre64.class)
+ .put("lisp", InterfaceTypeLisp.class)
+ .put("dpdk", InterfaceTypeDpdk.class)
+ .put("dpdkr", InterfaceTypeDpdkr.class)
+ .put("dpdkvhost", InterfaceTypeDpdkvhost.class)
+ .put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.class)
+ .build();
+
+ public NodeId createNodeId(IpAddress ip, PortNumber port) {
+ String uriString = SouthboundConstants.OVSDB_URI_PREFIX + "://"
+ + String.valueOf(ip.getValue()) + ":" + port.getValue();
+ Uri uri = new Uri(uriString);
+ return new NodeId(uri);
+ }
+
+ public Node createNode(ConnectionInfo key) {
+ NodeBuilder nodeBuilder = new NodeBuilder();
+ nodeBuilder.setNodeId(createNodeId(key.getRemoteIp(), key.getRemotePort()));
+ nodeBuilder.addAugmentation(OvsdbNodeAugmentation.class, createOvsdbAugmentation(key));
+ return nodeBuilder.build();
+ }
+
+ public OvsdbNodeAugmentation createOvsdbAugmentation(ConnectionInfo key) {
+ OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
+ ovsdbNodeBuilder.setConnectionInfo(key);
+ return ovsdbNodeBuilder.build();
+ }
+
+ public InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key) {
+ return createInstanceIdentifier(key.getRemoteIp(), key.getRemotePort());
+ }
+
+ public InstanceIdentifier<Node> createInstanceIdentifier(IpAddress ip, PortNumber port) {
+ InstanceIdentifier<Node> path = InstanceIdentifier
+ .create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class,createNodeKey(ip,port));
+ LOG.debug("Created ovsdb path: {}",path);
+ return path;
+ }
+
+ public InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key,OvsdbBridgeName bridgeName) {
+ return SouthboundMapper.createInstanceIdentifier(createManagedNodeId(key, bridgeName));
+ }
+
+ public InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(Node node, String portName){
+
+ InstanceIdentifier<TerminationPoint> terminationPointPath = InstanceIdentifier
+ .create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(OVSDB_TOPOLOGY_ID))
+ .child(Node.class,node.getKey())
+ .child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
+
+ LOG.debug("Termination point InstanceIdentifier generated : {}",terminationPointPath);
+ return terminationPointPath;
+ }
+
+ public NodeKey createNodeKey(IpAddress ip, PortNumber port) {
+ return new NodeKey(createNodeId(ip, port));
+ }
+
+ public NodeId createManagedNodeId(ConnectionInfo key, OvsdbBridgeName bridgeName) {
+ return createManagedNodeId(key.getRemoteIp(), key.getRemotePort(), bridgeName);
+ }
+
+ public NodeId createManagedNodeId(IpAddress ip, PortNumber port, OvsdbBridgeName bridgeName) {
+ return new NodeId(createNodeId(ip,port).getValue()
+ + "/" + SouthboundConstants.BRIDGE_URI_PREFIX + "/" + bridgeName.getValue());
+ }
+
+ public ConnectionInfo getConnectionInfo(final String addressStr, final String portStr) {
+ InetAddress inetAddress = null;
+ try {
+ inetAddress = InetAddress.getByName(addressStr);
+ } catch (UnknownHostException e) {
+ LOG.warn("Could not allocate InetAddress");
+ }
+
+ IpAddress address = SouthboundMapper.createIpAddress(inetAddress);
+ PortNumber port = new PortNumber(Integer.parseInt(portStr));
+
+ LOG.info("connectionInfo: {}", new ConnectionInfoBuilder()
+ .setRemoteIp(address)
+ .setRemotePort(port)
+ .build());
+ return new ConnectionInfoBuilder()
+ .setRemoteIp(address)
+ .setRemotePort(port)
+ .build();
+ }
+
+ public String connectionInfoToString(final ConnectionInfo connectionInfo) {
+ return String.valueOf(
+ connectionInfo.getRemoteIp().getValue()) + ":" + connectionInfo.getRemotePort().getValue();
+ }
+
+ public boolean addOvsdbNode(final ConnectionInfo connectionInfo) {
+ boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
+ createInstanceIdentifier(connectionInfo),
+ createNode(connectionInfo));
+ try {
+ Thread.sleep(OVSDB_UPDATE_TIMEOUT);
+ } catch (InterruptedException e) {
+ LOG.warn("Interrupted while waiting after adding OVSDB node {}", connectionInfoToString(connectionInfo), e);
+ }
+ return result;
+ }
+
+ public Node getOvsdbNode(final ConnectionInfo connectionInfo) {
+ return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
+ createInstanceIdentifier(connectionInfo));
+ }
+
+ public boolean deleteOvsdbNode(final ConnectionInfo connectionInfo) {
+ boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
+ createInstanceIdentifier(connectionInfo));
+ try {
+ Thread.sleep(OVSDB_UPDATE_TIMEOUT);
+ } catch (InterruptedException e) {
+ LOG.warn("Interrupted while waiting after deleting OVSDB node {}", connectionInfoToString(connectionInfo),
+ e);
+ }
+ return result;
+ }
+
+ public Node connectOvsdbNode(final ConnectionInfo connectionInfo) {
+ addOvsdbNode(connectionInfo);
+ Node node = getOvsdbNode(connectionInfo);
+ LOG.info("Connected to {}", connectionInfoToString(connectionInfo));
+ return node;
+ }
+
+ public boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) {
+ deleteOvsdbNode(connectionInfo);
+ LOG.info("Disconnected from {}", connectionInfoToString(connectionInfo));
+ return true;
+ }
+
+ public List<ControllerEntry> createControllerEntry(String controllerTarget) {
+ List<ControllerEntry> controllerEntriesList = new ArrayList<>();
+ controllerEntriesList.add(new ControllerEntryBuilder()
+ .setTarget(new Uri(controllerTarget))
+ .build());
+ return controllerEntriesList;
+ }
+
+ /**
+ * Extract the <code>store</code> type data store contents for the particular bridge identified by
+ * <code>bridgeName</code>.
+ *
+ * @param connectionInfo address for the node
+ * @param bridgeName name of the bridge
+ * @param store defined by the <code>LogicalDatastoreType</code> enumeration
+ * @return <code>store</code> type data store contents
+ */
+ public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
+ LogicalDatastoreType store) {
+ OvsdbBridgeAugmentation ovsdbBridgeAugmentation = null;
+ Node bridgeNode = getBridgeNode(connectionInfo, bridgeName, store);
+ if (bridgeNode != null) {
+ ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
+ }
+ return ovsdbBridgeAugmentation;
+ }
+
+ /**
+ * extract the <code>LogicalDataStoreType.OPERATIONAL</code> type data store contents for the particular bridge
+ * identified by <code>bridgeName</code>
+ *
+ * @param connectionInfo address for the node
+ * @param bridgeName name of the bridge
+ * @see <code>NetvirtIT.getBridge(ConnectionInfo, String, LogicalDatastoreType)</code>
+ * @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
+ */
+ public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
+ return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
+ }
+
+ /**
+ * Extract the node contents from <code>store</code> type data store for the
+ * bridge identified by <code>bridgeName</code>.
+ *
+ * @param connectionInfo address for the node
+ * @param bridgeName name of the bridge
+ * @param store defined by the <code>LogicalDatastoreType</code> enumeration
+ * @return <code>store</code> type data store contents
+ */
+ public Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
+ InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
+ return mdsalUtils.read(store, bridgeIid);
+ }
+
+ public boolean deleteBridge(final ConnectionInfo connectionInfo, final String bridgeName) {
+
+ boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
+ createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName)));
+ try {
+ Thread.sleep(OVSDB_UPDATE_TIMEOUT);
+ } catch (InterruptedException e) {
+ LOG.warn("Interrupted while waiting after deleting bridge {}", bridgeName, e);
+ }
+ return result;
+ }
+
+ public List<ProtocolEntry> createMdsalProtocols() {
+ List<ProtocolEntry> protocolList = new ArrayList<>();
+ ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
+ SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
+ protocolList.add(new ProtocolEntryBuilder().setProtocol(mapper.get("OpenFlow13")).build());
+ return protocolList;
+ }
+
+ /*
+ * base method for adding test bridges. Other helper methods used to create bridges should utilize this method.
+ *
+ * @param connectionInfo
+ * @param bridgeIid if passed null, one is created
+ * @param bridgeName cannot be null
+ * @param bridgeNodeId if passed null, one is created based on <code>bridgeIid</code>
+ * @param setProtocolEntries toggles whether default protocol entries are set for the bridge
+ * @param failMode toggles whether default fail mode is set for the bridge
+ * @param setManagedBy toggles whether to setManagedBy for the bridge
+ * @param dpType if passed null, this parameter is ignored
+ * @param externalIds if passed null, this parameter is ignored
+ * @param otherConfig if passed null, this parameter is ignored
+ * @return success of bridge addition
+ * @throws InterruptedException
+ */
+ public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
+ final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
+ final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
+ final Class<? extends DatapathTypeBase> dpType,
+ final List<BridgeExternalIds> externalIds,
+ final List<ControllerEntry> controllerEntries,
+ final List<BridgeOtherConfigs> otherConfigs,
+ final String dpid) throws InterruptedException {
+
+ NodeBuilder bridgeNodeBuilder = new NodeBuilder();
+ if (bridgeIid == null) {
+ bridgeIid = createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
+ }
+ if (bridgeNodeId == null) {
+ bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
+ }
+ bridgeNodeBuilder.setNodeId(bridgeNodeId);
+ OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
+ ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
+ if (setProtocolEntries) {
+ ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
+ }
+ if (failMode != null) {
+ ovsdbBridgeAugmentationBuilder.setFailMode(failMode);
+ }
+ if (setManagedBy) {
+ setManagedBy(ovsdbBridgeAugmentationBuilder, connectionInfo);
+ }
+ if (dpType != null) {
+ ovsdbBridgeAugmentationBuilder.setDatapathType(dpType);
+ }
+ if (externalIds != null) {
+ ovsdbBridgeAugmentationBuilder.setBridgeExternalIds(externalIds);
+ }
+ if (controllerEntries != null) {
+ ovsdbBridgeAugmentationBuilder.setControllerEntry(controllerEntries);
+ }
+ if (otherConfigs != null) {
+ ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(otherConfigs);
+ }
+ if (dpid != null && !dpid.isEmpty()) {
+ DatapathId datapathId = new DatapathId(dpid);
+ ovsdbBridgeAugmentationBuilder.setDatapathId(datapathId);
+ }
+ bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
+ LOG.debug("Built with the intent to store bridge data {}",
+ ovsdbBridgeAugmentationBuilder.toString());
+ boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
+ bridgeIid, bridgeNodeBuilder.build());
+ Thread.sleep(OVSDB_UPDATE_TIMEOUT);
+ return result;
+ }
+
+ public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
+ final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
+ final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
+ final Class<? extends DatapathTypeBase> dpType,
+ final List<BridgeExternalIds> externalIds,
+ final List<ControllerEntry> controllerEntries,
+ final List<BridgeOtherConfigs> otherConfigs) throws InterruptedException {
+ return addBridge(connectionInfo, bridgeIid, bridgeName, bridgeNodeId, setProtocolEntries,
+ failMode, setManagedBy, dpType, externalIds, controllerEntries,
+ otherConfigs, null);
+ }
+
+ public boolean addBridge(final ConnectionInfo connectionInfo, final String bridgeName)
+ throws InterruptedException {
+
+ return addBridge(connectionInfo, null, bridgeName, null, true,
+ SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get("secure"), true, null, null, null, null);
+ }
+
+ private void setManagedBy(final OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
+ final ConnectionInfo connectionInfo) {
+ InstanceIdentifier<Node> connectionNodePath = createInstanceIdentifier(connectionInfo);
+ ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
+ }
+
+ public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
+ String type, Map<String, String> options,
+ Map<String, String> externalIds, Long ofport) {
+ InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(bridgeNode, portName);
+ OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
+
+ tpAugmentationBuilder.setName(portName);
+ tpAugmentationBuilder.setOfport(ofport);
+ if (type != null) {
+ tpAugmentationBuilder.setInterfaceType(OVSDB_INTERFACE_TYPE_MAP.get(type));
+ }
+
+ if (options != null && options.size() > 0) {
+ List<Options> optionsList = new ArrayList<>();
+ for (Map.Entry<String, String> entry : options.entrySet()) {
+ OptionsBuilder optionsBuilder = new OptionsBuilder();
+ optionsBuilder.setKey(new OptionsKey(entry.getKey()));
+ optionsBuilder.setOption(entry.getKey());
+ optionsBuilder.setValue(entry.getValue());
+ optionsList.add(optionsBuilder.build());
+ }
+ tpAugmentationBuilder.setOptions(optionsList);
+ }
+
+ if (externalIds != null && externalIds.size() > 0) {
+ List<InterfaceExternalIds> externalIdsList = new ArrayList<>();
+ for (Map.Entry<String, String> entry : externalIds.entrySet()) {
+ InterfaceExternalIdsBuilder interfaceExternalIdsBuilder = new InterfaceExternalIdsBuilder();
+ interfaceExternalIdsBuilder.setKey(new InterfaceExternalIdsKey(entry.getKey()));
+ interfaceExternalIdsBuilder.setExternalIdKey(entry.getKey());
+ interfaceExternalIdsBuilder.setExternalIdValue(entry.getValue());
+ externalIdsList.add(interfaceExternalIdsBuilder.build());
+ }
+ tpAugmentationBuilder.setInterfaceExternalIds(externalIdsList);
+ }
+
+ TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
+ tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
+ tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
+ /* TODO SB_MIGRATION should this be merge or mdsalUtils.put */
+ return mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
+ }
+
+ public TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName) {
+ InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
+ bridgeNode, portName);
+ return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, tpIid);
+ }
+
+ public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type) {
+ return addTerminationPoint(bridgeNode, bridgeName, portName, type, null, null, null);
+ }
+ }