package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.DataStore.readFromDs;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.DataStore.submitToDs;
+import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
+import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
+
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.neutron.ovsdb.AbstractTunnelType;
-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.Uri;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
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.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.OvsdbBridgeRef;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbHelper {
- private static final Logger LOG = LoggerFactory.getLogger(DataStore.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OvsdbHelper.class);
private static final String OF_PORT = "6653";
/**
* Look up the {@link OvsdbBridgeAugmentation} from the data store
- * given a child {@link InstanceIdentifier<OvsdbTerminationPointAugmentation>}
+ * given a child {@link InstanceIdentifier} of {@link OvsdbTerminationPointAugmentation}.
*
- * @param tpId The InstanceIdentifier for a child TerminationPoint augmentation
+ * @param tpIid The InstanceIdentifier for a child TerminationPoint augmentation
+ * @param dataBroker the {@link DataBroker}
* @return the {@link OvsdbBridgeAugmentation}, null if the augmentation isn't present
*/
- public static OvsdbBridgeAugmentation getOvsdbBridge(
+ public static OvsdbBridgeAugmentation getOvsdbBridgeFromTerminationPoint(
InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid, DataBroker dataBroker) {
- InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid =
- tpIid.firstIdentifierOf(Node.class).augmentation(OvsdbBridgeAugmentation.class);
- if (ovsdbBridgeIid == null) {
- return null;
+ InstanceIdentifier<Node> nodeIid = tpIid.firstIdentifierOf(Node.class);
+ if (nodeIid != null) {
+ InstanceIdentifier<OvsdbBridgeAugmentation>
+ ovsdbBridgeIid = nodeIid.augmentation(OvsdbBridgeAugmentation.class);
+ if (ovsdbBridgeIid != null) {
+ ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
+ Optional<OvsdbBridgeAugmentation> ovsdbBridge =
+ readFromDs(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, transaction);
+ if (ovsdbBridge.isPresent()) {
+ return ovsdbBridge.get();
+ }
+ }
}
+ return null;
+ }
+
+ public static Node getNodeFromBridgeRef(OvsdbBridgeRef bridgeRef, DataBroker dataBroker) {
+ InstanceIdentifier<Node> nodeIid = bridgeRef.getValue().firstIdentifierOf(Node.class);
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<OvsdbBridgeAugmentation> ovsdbBridge =
- readFromDs(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, transaction );
- if (ovsdbBridge.isPresent()) {
- return ovsdbBridge.get();
+ Optional<?> node = readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction);
+ if (node.isPresent()) {
+ if (node.get() instanceof Node) {
+ return (Node) node.get();
+ }
}
return null;
}
public static OvsdbTerminationPointAugmentation getOvsdbTerminationPoint(
InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid, DataBroker dataBroker) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<OvsdbTerminationPointAugmentation> ovsdbTp =
- readFromDs(LogicalDatastoreType.OPERATIONAL, tpIid, transaction );
+ Optional<OvsdbTerminationPointAugmentation>
+ ovsdbTp = readFromDs(LogicalDatastoreType.OPERATIONAL, tpIid, transaction);
if (ovsdbTp.isPresent()) {
return ovsdbTp.get();
}
return tunnelType.getTunnelPrefix() + bridge.getBridgeName().getValue();
}
- public static OvsdbTerminationPointAugmentation buildOvsdbTerminationPointAugmentation(OvsdbBridgeAugmentation bridge,
- List<Options> options, AbstractTunnelType tunnelType) {
+ public static OvsdbTerminationPointAugmentation buildOvsdbTerminationPointAugmentation(
+ OvsdbBridgeAugmentation bridge, List<Options> options, AbstractTunnelType tunnelType) {
OvsdbTerminationPointAugmentationBuilder ovsdbTpBuilder = new OvsdbTerminationPointAugmentationBuilder();
ovsdbTpBuilder.setName(generateTpName(bridge, tunnelType));
ovsdbTpBuilder.setOptions(options);
}
/**
- * Get the manager node for this bridge node
+ * Get the manager node for this bridge node.
*
- * @param bridge
- * @param dataBroker
- * @return The {@link OvsdbBridgAugmentation} for the manager node, null
+ * @param bridge the bridge node
+ * @param dataBroker the {@link DataBroker}
+ * @return The {@link OvsdbBridgeAugmentation} for the manager node, null
* if not found or if it already is the manager node
*/
public static OvsdbNodeAugmentation getManagerNode(OvsdbBridgeAugmentation bridge, DataBroker dataBroker) {
OvsdbNodeRef bareIId = bridge.getManagedBy();
- if(bareIId != null) {
- if(bareIId.getValue().getTargetType().equals(Node.class)) {
+ if (bareIId != null) {
+ if (bareIId.getValue().getTargetType().equals(Node.class)) {
ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) bareIId.getValue();
Optional<Node> nodeOptional = readFromDs(LogicalDatastoreType.OPERATIONAL, iid, transaction);
- if(nodeOptional.isPresent()
- && nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class) != null) {
+ if (nodeOptional.isPresent()
+ && nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class) != null) {
return nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class);
} else {
- LOG.warn("Could not find ovsdb-node for connection for {}",bridge);
+ LOG.warn("Could not find ovsdb-node for connection for {}", bridge);
}
} else {
- LOG.warn("Bridge 'managedBy' non-ovsdb-node. bridge {} getManagedBy() {}",bridge,bareIId.getValue());
+ LOG.warn("Bridge 'managedBy' non-ovsdb-node. bridge {} getManagedBy() {}", bridge, bareIId.getValue());
}
} else {
LOG.debug("Bridge 'managedBy' is null. bridge {}",bridge);
public static Node getTopologyNode(InstanceIdentifier<Node> nodeIid, DataBroker dataBroker) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<Node> nodeOptional =
- readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction );
+ Optional<Node> nodeOptional = readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction);
if (nodeOptional.isPresent()) {
return nodeOptional.get();
}
* Use OVSDB CRUD to create any missing tunnels on a given
* Inventory Node.
*
- * @param nodeIid
- * @param node
- * @param tunnelType
+ * @param nodeIid the node instance identifier
+ * @param node the inventory node
+ * @param tunnelType the tunnel type
+ * @param dataBroker the {@link DataBroker}
*/
public static void createTunnelPort(InstanceIdentifier<Node> nodeIid,
Node node, AbstractTunnelType tunnelType, DataBroker dataBroker) {
- ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (bridge == null) {
LOG.warn("No OvsdbBridgeAugmentationfor Node {}", node);
}
OvsdbNodeAugmentation managerNode = getManagerNode(bridge, dataBroker);
- if(managerNode == null) {
+ if (managerNode == null) {
LOG.warn("Couldn't create tunnel port for Node {}, no manager", node);
return;
}
List<Options> options = tunnelType.getOptions();
- OvsdbTerminationPointAugmentation ovsdbTp =
- buildOvsdbTerminationPointAugmentation(bridge,options, tunnelType);
+ OvsdbTerminationPointAugmentation ovsdbTp = buildOvsdbTerminationPointAugmentation(bridge, options, tunnelType);
List<TerminationPoint> tps = buildTerminationPoints(bridge,ovsdbTp, tunnelType);
- OvsdbBridgeAugmentation ovsdbBridgeAugmentation =
- buildOvsdbBridgeAugmentation(bridge,managerNode);
+ OvsdbBridgeAugmentation ovsdbBridgeAugmentation = buildOvsdbBridgeAugmentation(bridge,managerNode);
Node configNode = getNode(node, tps,ovsdbBridgeAugmentation);
LOG.info("About to write nodeId {} node {}",nodeIid,configNode);
- transaction.put(LogicalDatastoreType.CONFIGURATION, nodeIid, configNode);
- submitToDs(transaction);
+ ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
+ rwTx.merge(LogicalDatastoreType.CONFIGURATION, nodeIid, configNode);
+ submitToDs(rwTx);
}
Code Review / groupbasedpolicy.git / blobdiff