import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.ovsdb.openstack.netvirt.ClusterAwareMdsalUtils;
import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
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.DatapathTypeNetdev;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdk;
-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.OvsdbBridgeAugmentationBuilder;
-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.OvsdbNodeAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
+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.BridgeOtherConfigsBuilder;
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;
*/
public class SouthboundImpl implements Southbound {
private static final Logger LOG = LoggerFactory.getLogger(SouthboundImpl.class);
- private DataBroker databroker = null;
+ private final DataBroker databroker;
private static final String PATCH_PORT_TYPE = "patch";
- private MdsalUtils mdsalUtils = null;
+ private final ClusterAwareMdsalUtils mdsalUtils;
/**
* Class constructor setting the data broker.
*/
public SouthboundImpl(DataBroker dataBroker) {
this.databroker = dataBroker;
- mdsalUtils = new MdsalUtils(dataBroker);
+ mdsalUtils = new ClusterAwareMdsalUtils(dataBroker);
}
public DataBroker getDatabroker() {
return ovsdbNodes;
}
+ public List<Node> readOvsdbTopologyBridgeNodes() {
+ List<Node> ovsdbNodes = new ArrayList<>();
+ InstanceIdentifier<Topology> topologyInstanceIdentifier = MdsalHelper.createInstanceIdentifier();
+ Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
+ if (topology != null && topology.getNode() != null) {
+ for (Node node : topology.getNode()) {
+ OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
+ if (ovsdbBridgeAugmentation != null) {
+ ovsdbNodes.add(node);
+ }
+ }
+ }
+ return ovsdbNodes;
+ }
+
public Node readOvsdbNode(Node bridgeNode) {
Node ovsdbNode = null;
OvsdbBridgeAugmentation bridgeAugmentation = extractBridgeAugmentation(bridgeNode);
return value;
}
- public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr) {
- boolean result = false;
+ public boolean addBridge(Node ovsdbNode, String bridgeName, List<String> controllersStr,
+ final Class<? extends DatapathTypeBase> dpType) {
+ boolean result;
LOG.info("addBridge: node: {}, bridgeName: {}, controller(s): {}", ovsdbNode, bridgeName, controllersStr);
ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
ovsdbBridgeAugmentationBuilder.setFailMode(
MdsalHelper.OVSDB_FAIL_MODE_MAP.inverse().get("secure"));
+ BridgeOtherConfigsBuilder bridgeOtherConfigsBuilder = new BridgeOtherConfigsBuilder();
+ bridgeOtherConfigsBuilder.setBridgeOtherConfigKey(MdsalHelper.DISABLE_IN_BAND);
+ bridgeOtherConfigsBuilder.setBridgeOtherConfigValue("true");
+ bridgeOtherConfigsBuilder.setBridgeOtherConfigKey(MdsalHelper.DISABLE_IN_BAND);
+ List<BridgeOtherConfigs> bridgeOtherConfigsList = new ArrayList<>();
+ bridgeOtherConfigsList.add(bridgeOtherConfigsBuilder.build());
+ ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(bridgeOtherConfigsList);
setManagedByForBridge(ovsdbBridgeAugmentationBuilder, ovsdbNode.getKey());
+ if (dpType != null) {
+ ovsdbBridgeAugmentationBuilder.setDatapathType(dpType);
+ }
if (isOvsdbNodeDpdk(ovsdbNode)) {
ovsdbBridgeAugmentationBuilder.setDatapathType(DatapathTypeNetdev.class);
}
}
public boolean deleteBridge(Node ovsdbNode) {
- boolean result = false;
InstanceIdentifier<Node> bridgeIid =
MdsalHelper.createInstanceIdentifier(ovsdbNode.getNodeId());
- result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, bridgeIid);
+ boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, bridgeIid);
LOG.info("deleteBridge node: {}, bridgeName: {} result : {}", ovsdbNode, ovsdbNode.getNodeId(),result);
return result;
}
Node ovsdbNode = node;
if (extractNodeAugmentation(ovsdbNode) == null) {
ovsdbNode = readOvsdbNode(node);
+ if (ovsdbNode == null) {
+ return null;
+ }
}
Node bridgeNode = null;
ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
}
public Node getBridgeNode(Node node, String bridgeName) {
- Node bridgeNode = null;
OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
if (bridge != null && bridge.getBridgeName().getValue().equals(bridgeName)) {
- bridgeNode = node;
+ return node;
} else {
- bridgeNode = readBridgeNode(node, bridgeName);
+ return readBridgeNode(node, bridgeName);
}
-
- return bridgeNode;
}
public String getBridgeUuid(Node node, String name) {
ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
}
- private void setControllersForBridge(Node ovsdbNode, String bridgeName, List<String> controllersString) {
- ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
- if (connectionInfo != null) {
- for (ControllerEntry controllerEntry : createControllerEntries(controllersString)) {
- InstanceIdentifier<ControllerEntry> iid =
- MdsalHelper.createInstanceIdentifier(ovsdbNode.getKey(), bridgeName)
- .augmentation(OvsdbBridgeAugmentation.class)
- .child(ControllerEntry.class, controllerEntry.getKey());
-
- boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, iid, controllerEntry);
- LOG.info("addController: result: {}", result);
- }
- }
- }
-
private List<ControllerEntry> createControllerEntries(List<String> controllersStr) {
List<ControllerEntry> controllerEntries = new ArrayList<>();
if (controllersStr != null) {
}
private List<ProtocolEntry> createMdsalProtocols() {
- List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
+ List<ProtocolEntry> protocolList = new ArrayList<>();
ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
MdsalHelper.OVSDB_PROTOCOL_MAP.inverse();
protocolList.add(new ProtocolEntryBuilder().
- setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
+ setProtocol(mapper.get("OpenFlow13")).build());
return protocolList;
}
}
public String getDatapathId(Node node) {
- String datapathId = null;
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
- if (ovsdbBridgeAugmentation != null && ovsdbBridgeAugmentation.getDatapathId() != null) {
- datapathId = node.getAugmentation(OvsdbBridgeAugmentation.class).getDatapathId().getValue();
- }
- return datapathId;
+ return getDatapathId(ovsdbBridgeAugmentation);
}
public String getDatapathId(OvsdbBridgeAugmentation ovsdbBridgeAugmentation) {
}
public List<Node> getAllBridgesOnOvsdbNode(Node node) {
- List<Node> nodes = new ArrayList<Node>();
+ List<Node> nodes = new ArrayList<>();
List<ManagedNodeEntry> managedNodes = node.getAugmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
for (ManagedNodeEntry managedNode : managedNodes) {
InstanceIdentifier<?> bridgeIid = managedNode.getBridgeRef().getValue();
}
public List<TerminationPoint> extractTerminationPoints(Node node) {
- List<TerminationPoint> terminationPoints = new ArrayList<TerminationPoint>();
+ List<TerminationPoint> terminationPoints = new ArrayList<>();
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (ovsdbBridgeAugmentation != null) {
terminationPoints.addAll(node.getTerminationPoint());
}
public List<OvsdbTerminationPointAugmentation> extractTerminationPointAugmentations( Node node ) {
- List<OvsdbTerminationPointAugmentation> tpAugmentations = new ArrayList<OvsdbTerminationPointAugmentation>();
+ List<OvsdbTerminationPointAugmentation> tpAugmentations = new ArrayList<>();
List<TerminationPoint> terminationPoints = node.getTerminationPoint();
if(terminationPoints != null && !terminationPoints.isEmpty()){
for(TerminationPoint tp : terminationPoints){
if(operNode != null){
return extractTerminationPointAugmentations(operNode);
}
- return new ArrayList<OvsdbTerminationPointAugmentation>();
+ return new ArrayList<>();
}
public String getInterfaceExternalIdsValue(
tpAugmentationBuilder.setInterfaceType(MdsalHelper.OVSDB_INTERFACE_TYPE_MAP.get(type));
}
- List<Options> optionsList = new ArrayList<Options>();
+ List<Options> optionsList = new ArrayList<>();
for (Map.Entry<String, String> entry : options.entrySet()) {
OptionsBuilder optionsBuilder = new OptionsBuilder();
optionsBuilder.setKey(new OptionsKey(entry.getKey()));
}
public Boolean addPatchTerminationPoint(Node node, String bridgeName, String portName, String peerPortName) {
- Map<String, String> option = new HashMap<String, String>();
+ Map<String, String> option = new HashMap<>();
option.put("peer", peerPortName);
return addTerminationPoint(node, bridgeName, portName, PATCH_PORT_TYPE, option);
}
OvsdbNodeAugmentation ovsdbNode = extractNodeAugmentation(node);
if (ovsdbNode == null) {
Node nodeFromReadOvsdbNode = readOvsdbNode(node);
- ovsdbNode = extractNodeAugmentation(nodeFromReadOvsdbNode);
+ if (nodeFromReadOvsdbNode != null) {
+ ovsdbNode = extractNodeAugmentation(nodeFromReadOvsdbNode);
+ }
}
if (ovsdbNode != null && ovsdbNode.getOpenvswitchExternalIds() != null) {
for (OpenvswitchExternalIds openvswitchExternalIds : ovsdbNode.getOpenvswitchExternalIds()) {
OvsdbNodeAugmentation ovsdbNode = extractNodeAugmentation(node);
if (ovsdbNode == null) {
Node nodeFromReadOvsdbNode = readOvsdbNode(node);
- ovsdbNode = extractNodeAugmentation(nodeFromReadOvsdbNode);
+ if (nodeFromReadOvsdbNode != null) {
+ ovsdbNode = extractNodeAugmentation(nodeFromReadOvsdbNode);
+ }
}
if (ovsdbNode != null && ovsdbNode.getOpenvswitchOtherConfigs() != null) {
for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs()) {
public String getOptionsValue(List<Options> options, String key) {
String value = null;
for (Options option : options) {
- if (option.getKey().equals(key)) {
+ if (option.getOption().equals(key)) {
value = option.getValue();
}
}
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(MdsalHelper.OVSDB_TOPOLOGY_ID));
- Topology topology = mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, path);
- return topology;
+ return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, path);
}
public Long getOFPort(OvsdbTerminationPointAugmentation port) {
Code Review / ovsdb.git / blobdiff