import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.neutron.spi.NeutronNetwork;
+import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.ClassifierProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
-import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
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.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
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.opendaylight.inventory.rev130819.nodes.NodeBuilder;
}
if (!tenantNetworkManager.isTenantNetworkPresentInNode(node, tunnelKey)) {
- logger.debug(node+" has no VM corresponding to segment "+ tunnelKey);
+ logger.debug(node + " has no VM corresponding to segment " + tunnelKey);
return new Status(StatusCode.NOTACCEPTABLE, node+" has no VM corresponding to segment "+ tunnelKey);
}
return new Status(StatusCode.SUCCESS);
InetAddress dst = InetAddress.getByName(
MdsalUtils.getOptionsValue(intf.getOptions(), "remote_ip"));
deleteTunnelPort(srcNode,
- SouthboundMapper.createOvsdbInterfaceType(intf.getInterfaceType()),
+ MdsalHelper.createOvsdbInterfaceType(intf.getInterfaceType()),
src, dst);
} catch (Exception e) {
logger.error(e.getMessage(), e);
ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
InstanceIdentifier<Flow> path1 =
InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
- .rev130819.nodes.Node.class,
+ .rev130819.nodes.Node.class,
nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class,
new TableKey(flowBuilder.getTableId())).child(Flow.class, flowBuilder.getKey()).build();
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
- <!--<dependency>
+ <dependency>
<groupId>org.apache.felix</groupId>
<artifactId>org.apache.felix.dependencymanager</artifactId>
- </dependency>-->
+ </dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.core</artifactId>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-common-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
<artifactId>neutron-spi</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
- <artifactId>southbound-impl</artifactId>
+ <artifactId>southbound-api</artifactId>
<version>1.1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
<artifactId>utils.servicehelper</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>ietf-inet-types</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools.model</groupId>
<artifactId>ietf-topology</artifactId>
- <!--<version>2013.10.21.7-SNAPSHOT</version>-->
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
package org.opendaylight.ovsdb.openstack.netvirt;
+import com.google.common.base.Preconditions;
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.InterfaceTypeSystem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeTap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow10;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow11;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow12;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow13;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow14;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow15;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeSecure;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeStandalone;
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.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;
public static final String BRIDGE_URI_PREFIX = "bridge";
public static final String TP_URI_PREFIX = "termination-point";
+ public static final ImmutableBiMap<Class<? extends OvsdbBridgeProtocolBase>,String> OVSDB_PROTOCOL_MAP
+ = new ImmutableBiMap.Builder<Class<? extends OvsdbBridgeProtocolBase>,String>()
+ .put(OvsdbBridgeProtocolOpenflow10.class,"OpenFlow10")
+ .put(OvsdbBridgeProtocolOpenflow11.class,"OpenFlow11")
+ .put(OvsdbBridgeProtocolOpenflow12.class,"OpenFlow12")
+ .put(OvsdbBridgeProtocolOpenflow13.class,"OpenFlow13")
+ .put(OvsdbBridgeProtocolOpenflow14.class,"OpenFlow14")
+ .put(OvsdbBridgeProtocolOpenflow15.class,"OpenFlow15")
+ .build();
+
+ public static final ImmutableBiMap<Class<? extends OvsdbFailModeBase>,String> OVSDB_FAIL_MODE_MAP
+ = new ImmutableBiMap.Builder<Class<? extends OvsdbFailModeBase>,String>()
+ .put(OvsdbFailModeStandalone.class,"standalone")
+ .put(OvsdbFailModeSecure.class,"secure")
+ .build();
+
public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP
= new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
.put("internal", InterfaceTypeInternal.class)
.build();
+ public static NodeId createManagedNodeId(InstanceIdentifier<Node> iid) {
+ NodeKey nodeKey = iid.firstKeyOf(Node.class, NodeKey.class);
+ return nodeKey.getNodeId();
+ }
+
public static NodeId createManagedNodeId(ConnectionInfo key, String bridgeName) {
- return createManagedNodeId(key.getRemoteIp(),key.getRemotePort(),bridgeName);
+ return createManagedNodeId(key.getRemoteIp(), key.getRemotePort(), bridgeName);
}
public static InstanceIdentifier<Node> createInstanceIdentifier(NodeId nodeId) {
return nodePath;
}
- public static InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key,String bridgeName) {
+ public static InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key) {
+ return createInstanceIdentifier(key.getRemoteIp(), key.getRemotePort());
+ }
+
+ public static InstanceIdentifier<Node> createInstanceIdentifier(IpAddress ip, PortNumber port) {
+ InstanceIdentifier<Node> path = InstanceIdentifier
+ .create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(OVSDB_TOPOLOGY_ID))
+ .child(Node.class,createNodeKey(ip,port));
+ LOG.debug("Created ovsdb path: {}",path);
+ return path;
+ }
+
+ public static NodeKey createNodeKey(IpAddress ip, PortNumber port) {
+ return new NodeKey(createNodeId(ip,port));
+ }
+
+ public static InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key, String bridgeName) {
return createInstanceIdentifier(createManagedNodeId(key, bridgeName));
}
+ public static InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key,OvsdbBridgeName bridgeName) {
+ return createInstanceIdentifier(createManagedNodeId(key, bridgeName));
+ }
+
+ public static NodeId createManagedNodeId(IpAddress ip, PortNumber port, OvsdbBridgeName bridgeName) {
+ return new NodeId(createNodeId(ip,port).getValue()
+ + "/" + BRIDGE_URI_PREFIX + "/" + bridgeName.getValue());
+ }
+
+ public static NodeId createManagedNodeId(ConnectionInfo key, OvsdbBridgeName bridgeName) {
+ return createManagedNodeId(key.getRemoteIp(), key.getRemotePort(), bridgeName);
+ }
+
public static NodeId createManagedNodeId(IpAddress ip, PortNumber port, String bridgeName) {
return new NodeId(createNodeId(ip,port).getValue()
+ "/" + BRIDGE_URI_PREFIX + "/" + bridgeName);
return createNodeId(connectionInfo.getRemoteIp(), connectionInfo.getRemotePort());
}
- public static InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(IpAddress ip, PortNumber port , String bridgeName, String portName){
+ public static InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(
+ IpAddress ip, PortNumber port, String bridgeName, String portName) {
String tpUri = createManagedNodeId(ip, port, bridgeName) + "/" + TP_URI_PREFIX + "/" + portName;
InstanceIdentifier<TerminationPoint> nodePath = InstanceIdentifier
.create(NetworkTopology.class)
LOG.debug("Termination point InstanceIdentigier generated : {}",nodePath);
return nodePath;
}
+
+ public static String createOvsdbInterfaceType(Class<? extends InterfaceTypeBase> mdsaltype) {
+ Preconditions.checkNotNull(mdsaltype);
+ ImmutableBiMap<Class<? extends InterfaceTypeBase>, String> mapper =
+ OVSDB_INTERFACE_TYPE_MAP.inverse();
+ return mapper.get(mdsaltype);
+ }
}
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
-import org.opendaylight.ovsdb.southbound.SouthboundConstants;
-import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
if (connectionInfo != null) {
NodeBuilder bridgeNodeBuilder = new NodeBuilder();
InstanceIdentifier<Node> bridgeIid =
- SouthboundMapper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
- NodeId bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
+ MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
+ NodeId bridgeNodeId = MdsalHelper.createManagedNodeId(bridgeIid);
bridgeNodeBuilder.setNodeId(bridgeNodeId);
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
ovsdbBridgeAugmentationBuilder.setControllerEntry(createControllerEntries(target));
ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
ovsdbBridgeAugmentationBuilder.setFailMode(
- SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get("secure"));
+ MdsalHelper.OVSDB_FAIL_MODE_MAP.inverse().get("secure"));
setManagedByForBridge(ovsdbBridgeAugmentationBuilder, connectionInfo);
bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
public static boolean deleteBridge(Node ovsdbNode) {
boolean result = false;
InstanceIdentifier<Node> bridgeIid =
- SouthboundMapper.createInstanceIdentifier(ovsdbNode.getNodeId());
+ MdsalHelper.createInstanceIdentifier(ovsdbNode.getNodeId());
result = delete(LogicalDatastoreType.CONFIGURATION, bridgeIid);
LOG.info("Delete bridge node: {}, bridgeName: {} result : {}", ovsdbNode, ovsdbNode.getNodeId(),result);
ConnectionInfo connectionInfo = getConnectionInfo(node);
if (connectionInfo != null) {
InstanceIdentifier<Node> bridgeIid =
- SouthboundMapper.createInstanceIdentifier(connectionInfo,
- new OvsdbBridgeName(name));
+ MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(name));
Node bridgeNode = read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
if (bridgeNode != null) {
ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
private static void setManagedByForBridge(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
ConnectionInfo connectionInfo) {
- InstanceIdentifier<Node> connectionNodePath = SouthboundMapper.createInstanceIdentifier(connectionInfo);
+ InstanceIdentifier<Node> connectionNodePath = MdsalHelper.createInstanceIdentifier(connectionInfo);
ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
}
if (connectionInfo != null) {
for (ControllerEntry controllerEntry: createControllerEntries(targetString)) {
InstanceIdentifier<ControllerEntry> iid =
- SouthboundMapper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName))
+ MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName))
.augmentation(OvsdbBridgeAugmentation.class)
.child(ControllerEntry.class, controllerEntry.getKey());
private static List<ProtocolEntry> createMdsalProtocols() {
List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
- SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
+ MdsalHelper.OVSDB_PROTOCOL_MAP.inverse();
protocolList.add(new ProtocolEntryBuilder().
setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
return protocolList;
}
public static List<OvsdbTerminationPointAugmentation> readTerminationPointAugmentationFromDataStore( Node node ) {
- InstanceIdentifier<Node> bridgeNodeIid = SouthboundMapper.createInstanceIdentifier(node.getNodeId());
+ InstanceIdentifier<Node> bridgeNodeIid = MdsalHelper.createInstanceIdentifier(node.getNodeId());
Node operNode = read(LogicalDatastoreType.OPERATIONAL, bridgeNodeIid);
if(operNode != null){
return extractTerminationPointAugmentations(operNode);
}
public static boolean isTunnel(OvsdbTerminationPointAugmentation port) {
- return SouthboundMapper.createOvsdbInterfaceType(
+ return MdsalHelper.createOvsdbInterfaceType(
port.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_VXLAN)
- || SouthboundMapper.createOvsdbInterfaceType(
+ || MdsalHelper.createOvsdbInterfaceType(
port.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE);
}
private static Topology getOvsdbTopology() {
InstanceIdentifier<Topology> path = InstanceIdentifier
.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
+ .child(Topology.class, new TopologyKey(MdsalHelper.OVSDB_TOPOLOGY_ID));
Topology topology = read(LogicalDatastoreType.OPERATIONAL, path);
return topology;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.openstack.netvirt.api.*;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
-import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
}
private boolean isInterfaceOfInterest(OvsdbTerminationPointAugmentation terminationPoint, List<String> phyIfName) {
- return (SouthboundMapper.createOvsdbInterfaceType(
+ return (MdsalHelper.createOvsdbInterfaceType(
terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_VXLAN)
||
- SouthboundMapper.createOvsdbInterfaceType(
+ MdsalHelper.createOvsdbInterfaceType(
terminationPoint.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE)
||
phyIfName.contains(terminationPoint.getName()));
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryListener;
-import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
this.dataBroker = dataBroker;
InstanceIdentifier<Node> path = InstanceIdentifier
.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Topology.class, new TopologyKey(MdsalHelper.OVSDB_TOPOLOGY_ID))
.child(Node.class);
registration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, path, this,
DataChangeScope.SUBTREE);
//Fetch data of removed connection info from original data
@SuppressWarnings("unchecked")
OvsdbNodeAugmentation removedOvsdbNodeAugmentationData = getDataChanges(changes.getOriginalData(),
- (InstanceIdentifier<OvsdbNodeAugmentation>)removedOvsdbNode);
+ (InstanceIdentifier<OvsdbNodeAugmentation>) removedOvsdbNode);
LOG.debug("Process ovsdb node delete : {} ", removedOvsdbNode);
////Assuming Openvswitch type represent the ovsdb node connection and not OvsdbType.NODE
*/
package org.opendaylight.ovsdb.openstack.netvirt.impl;
-import com.fasterxml.jackson.annotation.JsonIgnoreType;
+//import com.fasterxml.jackson.annotation.JsonIgnoreType;
import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.junit.Test;