Code Review / ovsdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
MD-SAL API integration
[ovsdb.git] / southbound / southbound-impl / src / main / java / org / opendaylight / ovsdb / southbound / ovsdb / transact / TerminationPointUpdateCommand.java
diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java
index f06b982a0ca85b05e3fcff9deeabc350c708396d..9df44ab503babd3fb3407fbd49138ed8cbacef9c 100644 (file)
--- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java
+++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java
@@ -11,8 +11,7 @@ import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
 import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
 
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -20,21 +19,19 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
 import org.opendaylight.ovsdb.lib.notation.UUID;
 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
-import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
 import org.opendaylight.ovsdb.schema.openvswitch.Port;
 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
 import org.opendaylight.ovsdb.southbound.SouthboundProvider;
+import org.opendaylight.ovsdb.southbound.SouthboundUtil;
 import org.opendaylight.ovsdb.utils.yang.YangUtils;
 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.OvsdbBridgeAugmentation;
@@ -53,6 +50,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.re
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -61,25 +60,26 @@ public class TerminationPointUpdateCommand implements TransactCommand {
     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointUpdateCommand.class);
 
     @Override
-    public void execute(TransactionBuilder transaction, BridgeOperationalState state,
-            DataChangeEvent events, InstanceIdentifierCodec instanceIdentifierCodec) {
+    public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final DataChangeEvent events, final InstanceIdentifierCodec instanceIdentifierCodec) {
         execute(transaction, state,
                 TransactUtils.extractCreatedOrUpdated(events, OvsdbTerminationPointAugmentation.class),
                 instanceIdentifierCodec);
     }
 
     @Override
-    public void execute(TransactionBuilder transaction, BridgeOperationalState state,
-            Collection<DataTreeModification<Node>> modifications, InstanceIdentifierCodec instanceIdentifierCodec) {
+    public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final Collection<DataTreeModification<Node>> modifications,
+            final InstanceIdentifierCodec instanceIdentifierCodec) {
         execute(transaction, state,
                 TransactUtils.extractCreatedOrUpdated(modifications, OvsdbTerminationPointAugmentation.class),
                 instanceIdentifierCodec);
     }
 
-    private void execute(TransactionBuilder transaction, BridgeOperationalState state,
-            Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
+    private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
                     createdOrUpdated,
-            InstanceIdentifierCodec instanceIdentifierCodec) {
+            final InstanceIdentifierCodec instanceIdentifierCodec) {
         for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
                  OvsdbTerminationPointAugmentation> terminationPointEntry : createdOrUpdated.entrySet()) {
             updateTerminationPoint(transaction, state, terminationPointEntry.getKey(),
@@ -87,20 +87,19 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    public void updateTerminationPoint(TransactionBuilder transaction, BridgeOperationalState state,
-            InstanceIdentifier<OvsdbTerminationPointAugmentation> iid,
-            OvsdbTerminationPointAugmentation terminationPoint, InstanceIdentifierCodec instanceIdentifierCodec) {
+    public void updateTerminationPoint(final TransactionBuilder transaction, final BridgeOperationalState state,
+            final InstanceIdentifier<OvsdbTerminationPointAugmentation> iid,
+            final OvsdbTerminationPointAugmentation terminationPoint,
+            final InstanceIdentifierCodec instanceIdentifierCodec) {
 
         if (terminationPoint != null) {
             LOG.debug("Received request to update termination point {}",
                    terminationPoint.getName());
 
             // Update interface
-            Interface ovsInterface =
-                    TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
+            Interface ovsInterface = transaction.getTypedRowWrapper(Interface.class);
             updateInterface(terminationPoint, ovsInterface);
-            Interface extraInterface = TyperUtils.getTypedRowWrapper(
-                    transaction.getDatabaseSchema(), Interface.class);
+            Interface extraInterface = transaction.getTypedRowWrapper(Interface.class);
             extraInterface.setName("");
             transaction.add(op.update(ovsInterface)
                     .where(extraInterface.getNameColumn().getSchema().opEqual(terminationPoint.getName()))
@@ -109,18 +108,16 @@ public class TerminationPointUpdateCommand implements TransactCommand {
             TerminationPointCreateCommand.stampInstanceIdentifier(transaction,
                     iid.firstIdentifierOf(OvsdbTerminationPointAugmentation.class), terminationPoint.getName(),
                     instanceIdentifierCodec);
-
+            final String opendaylightIid = instanceIdentifierCodec.serialize(iid);
             // Update port
             // Bug#6136
             Optional<OvsdbBridgeAugmentation> ovsdbBridgeOptional = state.getOvsdbBridgeAugmentation(iid);
             if (ovsdbBridgeOptional != null && ovsdbBridgeOptional.isPresent()) {
                 OvsdbBridgeAugmentation operBridge = ovsdbBridgeOptional.get();
                 if (operBridge != null) {
-                    Port port = TyperUtils.getTypedRowWrapper(
-                        transaction.getDatabaseSchema(), Port.class);
-                    updatePort(terminationPoint, port, operBridge);
-                    Port extraPort = TyperUtils.getTypedRowWrapper(
-                        transaction.getDatabaseSchema(), Port.class);
+                    Port port = transaction.getTypedRowWrapper(Port.class);
+                    updatePort(terminationPoint, port, operBridge, opendaylightIid);
+                    Port extraPort = transaction.getTypedRowWrapper(Port.class);
                     extraPort.setName("");
                     transaction.add(op.update(port)
                         .where(extraPort.getNameColumn().getSchema().opEqual(terminationPoint.getName()))
@@ -134,8 +131,7 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updateInterface(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterface(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
         updateOfPort(terminationPoint, ovsInterface);
         updateOfPortRequest(terminationPoint, ovsInterface);
@@ -147,23 +143,18 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         updateInterfacePolicing(terminationPoint, ovsInterface);
     }
 
-    private void updatePort(
-            final OvsdbTerminationPointAugmentation terminationPoint,
-            final Port port,
-            final OvsdbBridgeAugmentation operBridge) {
-
+    private static void updatePort(final OvsdbTerminationPointAugmentation terminationPoint,
+            final Port port, final OvsdbBridgeAugmentation operBridge, final String opendaylightIid) {
         updatePortOtherConfig(terminationPoint, port);
         updatePortVlanTag(terminationPoint, port);
         updatePortVlanTrunk(terminationPoint, port);
         updatePortVlanMode(terminationPoint, port);
-        updatePortExternalIds(terminationPoint, port);
+        updatePortExternalIds(terminationPoint, port, opendaylightIid);
         updatePortQos(terminationPoint, port, operBridge);
     }
 
-    private void updatePortQos(
-            final OvsdbTerminationPointAugmentation terminationPoint,
-            final Port port,
-            final OvsdbBridgeAugmentation operBridge) {
+    private static void updatePortQos(final OvsdbTerminationPointAugmentation terminationPoint,
+            final Port port, final OvsdbBridgeAugmentation operBridge) {
 
         Set<UUID> uuidSet = new HashSet<>();
 
@@ -188,46 +179,41 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         port.setQos(uuidSet);
     }
 
-    private OvsdbNodeAugmentation getOperNode(final OvsdbBridgeAugmentation operBridge) {
+    @SuppressWarnings("IllegalCatch")
+    private static OvsdbNodeAugmentation getOperNode(final OvsdbBridgeAugmentation operBridge) {
         @SuppressWarnings("unchecked")
         InstanceIdentifier<Node> iidNode = (InstanceIdentifier<Node>)operBridge.getManagedBy().getValue();
         OvsdbNodeAugmentation operNode = null;
-        ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction();
-        CheckedFuture<Optional<Node>, ReadFailedException> future =
-                transaction.read(LogicalDatastoreType.OPERATIONAL, iidNode);
-        try {
-            Optional<Node> nodeOptional = future.get();
+        try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
+            Optional<Node> nodeOptional = SouthboundUtil.readNode(transaction, iidNode);
             if (nodeOptional.isPresent()) {
                 operNode = nodeOptional.get().augmentation(OvsdbNodeAugmentation.class);
             }
-        } catch (InterruptedException | ExecutionException e) {
-            LOG.warn("Error reading from datastore", e);
+        } catch (Exception exp) {
+            LOG.error("Error in getting the brideNode for {}", iidNode, exp);
         }
         return operNode;
     }
 
-    private void updateOfPort(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateOfPort(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
-        Long ofPort = terminationPoint.getOfport();
+        Uint32 ofPort = terminationPoint.getOfport();
         if (ofPort != null) {
-            ovsInterface.setOpenFlowPort(Collections.singleton(ofPort));
+            ovsInterface.setOpenFlowPort(Collections.singleton(ofPort.toJava()));
         }
     }
 
-    private void updateOfPortRequest(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateOfPortRequest(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
-        Integer ofPortRequest = terminationPoint.getOfportRequest();
+        Uint16 ofPortRequest = terminationPoint.getOfportRequest();
         if (ofPortRequest != null) {
             ovsInterface.setOpenFlowPortRequest(Collections.singleton(ofPortRequest.longValue()));
         }
     }
 
-    private void updateInterfaceOptions(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterfaceOptions(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
         //Configure optional input
@@ -241,26 +227,28 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updateInterfaceExternalIds(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterfaceExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
         List<InterfaceExternalIds> interfaceExternalIds =
                 terminationPoint.getInterfaceExternalIds();
         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
-            try {
-                ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
-                        InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
-            } catch (NullPointerException e) {
-                LOG.warn("Incomplete OVSDB interface external_ids", e);
-            }
+            interfaceExternalIds.add(SouthboundUtil.createExternalIdsForInterface(
+                SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+        } else {
+            interfaceExternalIds = Arrays.asList(SouthboundUtil.createExternalIdsForInterface(
+                SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+        }
+        try {
+            ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
+                    InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
+        } catch (NullPointerException e) {
+            LOG.warn("Incomplete OVSDB interface external_ids", e);
         }
     }
 
-    private void updateInterfaceLldp(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterfaceLldp(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
-
         try {
             List<InterfaceLldp> interfaceLldpList =
                     terminationPoint.getInterfaceLldp();
@@ -277,8 +265,7 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updateInterfaceOtherConfig(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterfaceOtherConfig(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
         List<InterfaceOtherConfigs> interfaceOtherConfigs =
@@ -297,8 +284,7 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updateInterfaceBfd(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
         try {
@@ -317,39 +303,35 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updateInterfacePolicing(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updateInterfacePolicing(final OvsdbTerminationPointAugmentation terminationPoint,
             final Interface ovsInterface) {
 
-        Long ingressPolicingRate = terminationPoint.getIngressPolicingRate();
+        Uint32 ingressPolicingRate = terminationPoint.getIngressPolicingRate();
         if (ingressPolicingRate != null) {
-            ovsInterface.setIngressPolicingRate(ingressPolicingRate);
+            ovsInterface.setIngressPolicingRate(ingressPolicingRate.toJava());
         }
-        Long ingressPolicingBurst = terminationPoint.getIngressPolicingBurst();
+        Uint32 ingressPolicingBurst = terminationPoint.getIngressPolicingBurst();
         if (ingressPolicingBurst != null) {
-            ovsInterface.setIngressPolicingBurst(ingressPolicingBurst);
+            ovsInterface.setIngressPolicingBurst(ingressPolicingBurst.toJava());
         }
     }
 
-    private void updatePortExternalIds(
-            final OvsdbTerminationPointAugmentation terminationPoint,
-            final Port port) {
+    private static void updatePortExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
+            final Port port, final String opendaylightIid) {
 
-        List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
-        if (portExternalIds != null && !portExternalIds.isEmpty()) {
-            try {
-                port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
-                        PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
-            } catch (NullPointerException e) {
-                LOG.warn("Incomplete OVSDB port external_ids", e);
-            }
+        Map<String, String> externalIdMap = new HashMap<>();
+        externalIdMap.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid);
+        externalIdMap.put(SouthboundConstants.CREATED_BY, SouthboundConstants.ODL);
+        try {
+            YangUtils.copyYangKeyValueListToMap(externalIdMap, terminationPoint.getPortExternalIds(),
+                    PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue);
+        } catch (NullPointerException e) {
+            LOG.warn("Incomplete OVSDB port external_ids", e);
         }
+        port.setExternalIds(externalIdMap);
     }
 
-    private void updatePortVlanTag(
-            final OvsdbTerminationPointAugmentation terminationPoint,
-            final Port port) {
-
+    private static void updatePortVlanTag(final OvsdbTerminationPointAugmentation terminationPoint, final Port port) {
         if (terminationPoint.getVlanTag() != null) {
             Set<Long> vlanTag = new HashSet<>();
             vlanTag.add(terminationPoint.getVlanTag().getValue().longValue());
@@ -357,10 +339,7 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updatePortVlanTrunk(
-            final OvsdbTerminationPointAugmentation terminationPoint,
-            final Port port) {
-
+    private static void updatePortVlanTrunk(final OvsdbTerminationPointAugmentation terminationPoint, final Port port) {
         if (terminationPoint.getTrunks() != null && terminationPoint.getTrunks().size() > 0) {
             Set<Long> portTrunks = new HashSet<>();
             List<Trunks> modelTrunks = terminationPoint.getTrunks();
@@ -373,9 +352,7 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updatePortVlanMode(
-            final OvsdbTerminationPointAugmentation terminationPoint,
-            final Port port) {
+    private static void updatePortVlanMode(final OvsdbTerminationPointAugmentation terminationPoint, final Port port) {
         if (terminationPoint.getVlanMode() != null) {
             Set<String> portVlanMode = new HashSet<>();
             VlanMode modelVlanMode = terminationPoint.getVlanMode();
@@ -384,8 +361,7 @@ public class TerminationPointUpdateCommand implements TransactCommand {
         }
     }
 
-    private void updatePortOtherConfig(
-            final OvsdbTerminationPointAugmentation terminationPoint,
+    private static void updatePortOtherConfig(final OvsdbTerminationPointAugmentation terminationPoint,
             final Port ovsPort) {
         List<PortOtherConfigs> portOtherConfigs =
                 terminationPoint.getPortOtherConfigs();
@@ -398,5 +374,4 @@ public class TerminationPointUpdateCommand implements TransactCommand {
             }
         }
     }
-
 }
Open vSwitch Database Management Protocol