Merge "BUG 5746 - Ovsdb QoS and Queue model enhancements"

diff --combined southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java
index 0fa399cbb22c69670caa5ae9d307a2852ac823de,0425d39e874eead6b1c9e2c07aee5cb51aeb0f6b..661b8814a666eae0271787664388d4fe388e6d44
--- 1/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TerminationPointUpdateCommand.java
--- 2/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
@@@ -8,7 -8,6 +8,7 @@@
  package org.opendaylight.ovsdb.southbound.ovsdb.transact;
  
  import static org.opendaylight.ovsdb.lib.operations.Operations.op;
 +import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
  
  import java.util.Collection;
  import java.util.HashMap;
@@@ -17,20 -16,32 +17,32 @@@ import java.util.List
  import java.util.Map;
  import java.util.Map.Entry;
  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.AsyncDataChangeEvent;
+ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+ import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  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.OvsdbConnectionInstance;
  import org.opendaylight.ovsdb.southbound.SouthboundConstants;
+ import org.opendaylight.ovsdb.southbound.SouthboundProvider;
  import org.opendaylight.ovsdb.utils.yang.YangUtils;
+ 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.OvsdbPortInterfaceAttributes.VlanMode;
+ 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.OvsdbQosRef;
  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.ovsdb.node.attributes.QosEntries;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
  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.InterfaceLldp;
@@@ -45,7 -56,9 +57,9 @@@ import org.opendaylight.yangtools.yang.
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
+ import com.google.common.base.Optional;
  import com.google.common.collect.Sets;
+ import com.google.common.util.concurrent.CheckedFuture;
  
  public class TerminationPointUpdateCommand implements TransactCommand {
  
@@@ -54,27 -67,27 +68,27 @@@
      @Override
      public void execute(TransactionBuilder transaction, BridgeOperationalState state,
                          AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> events) {
-         execute(transaction, TransactUtils.extractCreatedOrUpdated(events, OvsdbTerminationPointAugmentation.class));
+         execute(transaction, state, TransactUtils.extractCreatedOrUpdated(events, OvsdbTerminationPointAugmentation.class));
      }
  
      @Override
      public void execute(TransactionBuilder transaction, BridgeOperationalState state,
                          Collection<DataTreeModification<Node>> modifications) {
-         execute(transaction,
+         execute(transaction, state,
                  TransactUtils.extractCreatedOrUpdated(modifications, OvsdbTerminationPointAugmentation.class));
      }
  
-     private void execute(TransactionBuilder transaction,
+     private void execute(TransactionBuilder transaction, BridgeOperationalState state,
                           Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
                                   OvsdbTerminationPointAugmentation> createdOrUpdated) {
          LOG.trace("TerminationPointUpdateCommand called");
          for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
                  OvsdbTerminationPointAugmentation> terminationPointEntry : createdOrUpdated.entrySet()) {
-             updateTerminationPoint(transaction, terminationPointEntry.getKey(), terminationPointEntry.getValue());
+             updateTerminationPoint(transaction, state, terminationPointEntry.getKey(), terminationPointEntry.getValue());
          }
      }
  
-     public void updateTerminationPoint(TransactionBuilder transaction,
+     public void updateTerminationPoint(TransactionBuilder transaction, BridgeOperationalState state,
                                         InstanceIdentifier<OvsdbTerminationPointAugmentation> iid,
                                         OvsdbTerminationPointAugmentation terminationPoint) {
          if (terminationPoint != null) {
@@@ -96,9 -109,10 +110,10 @@@
                      iid.firstIdentifierOf(OvsdbTerminationPointAugmentation.class), terminationPoint.getName());
  
              // Update port
+             OvsdbBridgeAugmentation operBridge = state.getBridgeNode(iid).get().getAugmentation(OvsdbBridgeAugmentation.class);
              Port port = TyperUtils.getTypedRowWrapper(
                      transaction.getDatabaseSchema(), Port.class);
-             updatePort(terminationPoint, port);
+             updatePort(terminationPoint, port, operBridge);
              Port extraPort = TyperUtils.getTypedRowWrapper(
                      transaction.getDatabaseSchema(), Port.class);
              extraPort.setName("");
@@@ -118,32 -132,74 +133,74 @@@
          updateInterfaceExternalIds(terminationPoint, ovsInterface);
          updateInterfaceLldp(terminationPoint, ovsInterface);
          updateInterfaceBfd(terminationPoint, ovsInterface);
+         updateInterfacePolicing(terminationPoint, ovsInterface);
      }
  
      private void updatePort(
              final OvsdbTerminationPointAugmentation terminationPoint,
-             final Port port) {
+             final Port port,
+             final OvsdbBridgeAugmentation operBridge) {
  
          updatePortOtherConfig(terminationPoint, port);
          updatePortVlanTag(terminationPoint, port);
          updatePortVlanTrunk(terminationPoint, port);
          updatePortVlanMode(terminationPoint, port);
          updatePortExternalIds(terminationPoint, port);
-         updatePortQos(terminationPoint, port);
+         updatePortQos(terminationPoint, port, operBridge);
      }
  
      private void updatePortQos(
              final OvsdbTerminationPointAugmentation terminationPoint,
-             final Port port) {
+             final Port port,
+             final OvsdbBridgeAugmentation operBridge) {
  
          Set<UUID> uuidSet = Sets.newHashSet();
-         Uuid qosUuid = terminationPoint.getQos();
-         if (qosUuid != null) {
-             uuidSet.add(new UUID(qosUuid.getValue()));
+ 
+         // First check if QosEntry is present and use that
+         if (terminationPoint.getQosEntry() != null && !terminationPoint.getQosEntry().isEmpty()) {
+             OvsdbQosRef qosRef = terminationPoint.getQosEntry().iterator().next().getQosRef();
+             Uri qosId = qosRef.getValue().firstKeyOf(QosEntries.class).getQosId();
+             OvsdbNodeAugmentation operNode = getOperNode(operBridge);
+             if (operNode != null && operNode.getQosEntries() != null &&
+                     !operNode.getQosEntries().isEmpty()) {
+                 for (QosEntries qosEntry : operNode.getQosEntries()) {
+                     if (qosEntry.getQosId().equals(qosId)) {
+                         uuidSet.add(new UUID(qosEntry.getQosUuid().getValue()));
+                     }
+                 }
+             }
+             if (uuidSet.size() == 0) {
+                 uuidSet.add(new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX +
+                             TransactUtils.bytesToHexString(qosId.getValue().getBytes())));
+             }
+         } else {
+             // Second check if Qos is present and use that (deprecated)
+             // Do not bother to check if QosEntry and Qos are consistent if both are present
+             Uuid qosUuid = terminationPoint.getQos();
+             if (qosUuid != null) {
+                 uuidSet.add(new UUID(qosUuid.getValue()));
+             }
          }
          port.setQos(uuidSet);
      }
  
+     private 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();
+             if (nodeOptional.isPresent()) {
+                 operNode = nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class);
+             }
+         } catch (InterruptedException | ExecutionException e) {
+             LOG.warn("Error reading from datastore", e);
+         }
+         return operNode;
+     }
  
      private void updateOfPort(
              final OvsdbTerminationPointAugmentation terminationPoint,
@@@ -212,7 -268,7 +269,7 @@@
                  }
              }
          } catch (SchemaVersionMismatchException e) {
 -            LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema", e);
 +            schemaMismatchLog("lldp", "Interface", e);
          }
      }
  
@@@ -252,10 -308,24 +309,24 @@@
                  }
              }
          } catch (SchemaVersionMismatchException e) {
 -            LOG.debug("bfd column for Interface Table unsupported for this version of ovsdb schema", e);
 +            schemaMismatchLog("bfd", "Interface", e);
          }
      }
  
+     private void updateInterfacePolicing(
+             final OvsdbTerminationPointAugmentation terminationPoint,
+             final Interface ovsInterface) {
+ 
+         Long ingressPolicingRate = terminationPoint.getIngressPolicingRate();
+         if (ingressPolicingRate != null) {
+             ovsInterface.setIngressPolicingRate(ingressPolicingRate);
+         }
+         Long ingressPolicingBurst = terminationPoint.getIngressPolicingBurst();
+         if (ingressPolicingBurst != null) {
+             ovsInterface.setIngressPolicingBurst(ingressPolicingBurst);
+         }
+     }
+ 
      private void updatePortExternalIds(
              final OvsdbTerminationPointAugmentation terminationPoint,
              final Port port) {

diff --combined southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
index 0877ac8459f2f1e64b3a021e71cb1f21f3d9432e,3accf490c5fcf8b38ea97d749a19112fee78ef5e..c5e565a2d53add51b093741c64ca96342dd92ef4
--- 1/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
--- 2/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
+++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
@@@ -48,6 -48,8 +48,6 @@@ import org.opendaylight.yangtools.yang.
  import org.opendaylight.yangtools.yang.binding.Identifier;
  import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 -import org.slf4j.Logger;
 -import org.slf4j.LoggerFactory;
  
  import com.google.common.base.Predicates;
  import com.google.common.collect.ImmutableMap;
@@@ -56,6 -58,8 +56,6 @@@ import com.google.common.collect.Maps
  import com.google.common.collect.Sets;
  
  public class TransactUtils {
 -    private static final Logger LOG = LoggerFactory.getLogger(TransactUtils.class);
 -
      private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataBefore() {
          return new Predicate<DataObjectModification<T>>() {
              @Override
@@@ -381,9 -385,13 +381,9 @@@
          if (child.getIdentifier() instanceof InstanceIdentifier.IdentifiableItem) {
              K key = (K) ((InstanceIdentifier.IdentifiableItem) child.getIdentifier()).getKey();
              KeyedInstanceIdentifier<N, K> extendedPath = path.child(item, key);
 -            LOG.debug("Building a new child iid for {} with {} and key {}, resulting in {}",
 -                    path, item, extendedPath);
              return extendedPath;
          } else {
              InstanceIdentifier<N> extendedPath = path.child(item);
 -            LOG.debug("Building a new child iid for {} with {}, resulting in {}",
 -                    path, item, extendedPath);
              return extendedPath;
          }
      }
@@@ -484,4 -492,41 +484,41 @@@
          mutate.setMutations(mutations);
          return mutate;
      }
+ 
+     /**
+      * This method builds a string by concatenating the 2 character
+      * hexadecimal representation of each byte from the input byte array.
+      *
+      * For example: an input byte array containing:
+      *   bytes[0] = 'a'
+      *   bytes[1] = 'b'
+      *   bytes[2] = 'c'
+      *   bytes[3] = '-'
+      *   bytes[4] = '1'
+      *   bytes[5] = '2'
+      *   bytes[6] = '3'
+      * returns the string "6162632d313233"
+      *
+      * @param bytes
+      *            The byte array to convert to string
+      * @return The hexadecimal representation of the byte array. If bytes is
+      *         null, the string "" is returned
+      */
+     public static String bytesToHexString(byte[] bytes) {
+ 
+         if (bytes == null) {
+             return "";
+         }
+ 
+         StringBuffer buf = new StringBuffer();
+         for (int i = 0; i < bytes.length; i++) {
+             short u8byte = (short) (bytes[i] & 0xff);
+             String tmp = Integer.toHexString(u8byte);
+             if (tmp.length() == 1) {
+                 buf.append("0");
+             }
+             buf.append(tmp);
+         }
+         return buf.toString();
+     }
  }

diff --combined southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java
index 6d7b3215a638e0862eceb87c688fae2a4c745754,da65b5b13e5bee7b344c564a5beb6b6645df5c55..7a5123dfde1d5afeb57f69dd8508e92ba1c4595a
--- 1/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java
--- 2/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java
+++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java
@@@ -8,8 -8,6 +8,8 @@@
  
  package org.opendaylight.ovsdb.southbound.transactions.md;
  
 +import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
 +
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
@@@ -32,17 -30,22 +32,22 @@@ import org.opendaylight.ovsdb.lib.schem
  import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  import org.opendaylight.ovsdb.schema.openvswitch.Port;
+ import org.opendaylight.ovsdb.schema.openvswitch.Qos;
  import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  import org.opendaylight.ovsdb.southbound.SouthboundUtil;
+ 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.l2.types.rev130827.VlanId;
  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.OvsdbPortInterfaceAttributes;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef;
  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.ovsdb.node.attributes.ManagedNodeEntry;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdBuilder;
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
@@@ -63,6 -66,9 +68,9 @@@ import org.opendaylight.yang.gen.v1.urn
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntry;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryBuilder;
+ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryKey;
  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.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
  import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
@@@ -88,6 -94,7 +96,7 @@@ public class OvsdbPortUpdateCommand ext
      private Map<UUID, Interface> interfaceUpdatedRows;
      private Map<UUID, Interface> interfaceOldRows;
      private Map<UUID, Bridge> bridgeUpdatedRows;
+     private Map<UUID, Qos> qosUpdatedRows;
      public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates,
              DatabaseSchema dbSchema) {
          super(key, updates, dbSchema);
@@@ -96,6 -103,7 +105,7 @@@
          interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema);
          interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema);
          bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema);
+         qosUpdatedRows = TyperUtils.extractRowsUpdated(Qos.class, updates, dbSchema);
      }
  
      @Override
@@@ -128,7 -136,7 +138,7 @@@
                          getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue());
                  OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
                          new OvsdbTerminationPointAugmentationBuilder();
-                 buildTerminationPoint(tpAugmentationBuilder,portUpdate.getValue());
+                 buildTerminationPoint(transaction, tpPath, tpAugmentationBuilder, node, portUpdate);
                  UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
                  if (interfaceUpdatedRows.containsKey(interfaceUUID)) {
                      buildTerminationPoint(tpAugmentationBuilder,
@@@ -171,14 -179,16 +181,16 @@@
          }
  
      }
-     private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
-             Port portUpdate) {
+     private void buildTerminationPoint(ReadWriteTransaction transaction,
+             InstanceIdentifier<TerminationPoint> tpPath,
+             OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
+             Node node, Entry<UUID, Port> portUpdate) {
  
          tpAugmentationBuilder
-                 .setName(portUpdate.getName());
+                 .setName(portUpdate.getValue().getName());
          tpAugmentationBuilder.setPortUuid(new Uuid(
-                 portUpdate.getUuid().toString()));
-         updatePort(portUpdate, tpAugmentationBuilder);
+                 portUpdate.getValue().getUuid().toString()));
+         updatePort(transaction, node, tpPath, portUpdate, tpAugmentationBuilder);
      }
  
      private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
@@@ -239,15 -249,16 +251,16 @@@
          updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
      }
  
-     private void updatePort(final Port port,
+     private void updatePort(final ReadWriteTransaction transaction, final Node node,
+             final InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
              final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
  
-         updateVlan(port, ovsdbTerminationPointBuilder);
-         updateVlanTrunks(port, ovsdbTerminationPointBuilder);
-         updateVlanMode(port, ovsdbTerminationPointBuilder);
-         updateQos(port, ovsdbTerminationPointBuilder);
-         updatePortExternalIds(port, ovsdbTerminationPointBuilder);
-         updatePortOtherConfig(port, ovsdbTerminationPointBuilder);
+         updateVlan(port.getValue(), ovsdbTerminationPointBuilder);
+         updateVlanTrunks(port.getValue(), ovsdbTerminationPointBuilder);
+         updateVlanMode(port.getValue(), ovsdbTerminationPointBuilder);
+         updateQos(transaction, node, tpPath, port, ovsdbTerminationPointBuilder);
+         updatePortExternalIds(port.getValue(), ovsdbTerminationPointBuilder);
+         updatePortOtherConfig(port.getValue(), ovsdbTerminationPointBuilder);
      }
  
      private void updateInterface(final Interface interf,
@@@ -266,6 -277,7 +279,7 @@@
          updateInterfaceLldp(interf, ovsdbTerminationPointBuilder);
          updateInterfaceBfd(interf, ovsdbTerminationPointBuilder);
          updateInterfaceBfdStatus(interf, ovsdbTerminationPointBuilder);
+         updateInterfacePolicing(interf, ovsdbTerminationPointBuilder);
      }
  
      private void updateVlan(final Port port,
@@@ -321,17 -333,81 +335,81 @@@
          }
      }
  
-     private void updateQos(final Port port,
-             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
-         if (port.getQosColumn() == null) {
+     private void updateQos(final ReadWriteTransaction transaction, final Node node, InstanceIdentifier<TerminationPoint> tpPath,
+             final Entry<UUID, Port> port, final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+         if (port.getValue() == null) {
              return;
          }
-         Collection<UUID> qosUuidCol = port.getQosColumn().getData();
+         Collection<UUID> qosUuidCol = port.getValue().getQosColumn().getData();
          if (!qosUuidCol.isEmpty()) {
-             Iterator<UUID> itr = qosUuidCol.iterator();
-             UUID qosUuid = itr.next();
+             UUID qosUuid = qosUuidCol.iterator().next();
              ovsdbTerminationPointBuilder.setQos(new Uuid(qosUuid.toString()));
+ 
+             NodeId nodeId = node.getNodeId();
+             OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
+ 
+             // Delete an older QoS entry
+             if (portOldRows.containsKey(port.getKey()) &&
+                     portOldRows.get(port.getKey()).getQosColumn() != null) {
+                 Collection<UUID> oldQos = portOldRows.get(port.getKey()).getQosColumn().getData();
+                 if (!oldQos.isEmpty()) {
+                     UUID oldQosUuid = oldQos.iterator().next();
+                     if (!oldQosUuid.equals(qosUuid)) {
+                         InstanceIdentifier<QosEntries> oldQosIid = getQosIid(nodeId, ovsdbNode, oldQosUuid);
+                         if (oldQosIid != null) {
+                             InstanceIdentifier<QosEntry> oldPortQosIid = tpPath
+                                 .augmentation(OvsdbTerminationPointAugmentation.class)
+                                 .child(QosEntry.class,
+                                       new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY)));
+ //                                    new QosEntryKey(new OvsdbQosRef(oldQosIid)));
+                             transaction.delete(LogicalDatastoreType.OPERATIONAL, oldPortQosIid);
+                         }
+                     }
+                 }
+             }
+ 
+             InstanceIdentifier<QosEntries> qosIid = getQosIid(nodeId, ovsdbNode, qosUuid);
+             if (qosIid != null) {
+                 List<QosEntry> qosList = new ArrayList<>();
+                 OvsdbQosRef qosRef = new OvsdbQosRef(qosIid);
+                 qosList.add(new QosEntryBuilder()
+                     .setKey(new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY)))
+                     .setQosRef(qosRef).build());
+                 ovsdbTerminationPointBuilder.setQosEntry(qosList);
+             }
+         }
+     }
+ 
+     private InstanceIdentifier<QosEntries> getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) {
+         // Search for the QoS entry first in the operational datastore
+         for (QosEntries qosEntry : ovsdbNode.getQosEntries()) {
+             if (qosEntry.getQosUuid().equals(new Uuid(qosUuid.toString()))) {
+                 return SouthboundMapper.createInstanceIdentifier(nodeId)
+                         .augmentation(OvsdbNodeAugmentation.class)
+                         .child(QosEntries.class, new QosEntriesKey(qosEntry.getQosId()));
+             }
+         }
+ 
+         // Search for the QoS entry in the current OVS updates
+         for (Entry<UUID, Qos> qosUpdate : qosUpdatedRows.entrySet()) {
+             Qos qos = qosUpdate.getValue();
+             if (qos.getUuid().equals(qosUuid)) {
+                 if (qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
+                     return (InstanceIdentifier<QosEntries>) SouthboundUtil.deserializeInstanceIdentifier(
+                             qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
+                 } else {
+                     return SouthboundMapper.createInstanceIdentifier(nodeId)
+                             .augmentation(OvsdbNodeAugmentation.class)
+                             .child(QosEntries.class, new QosEntriesKey(
+                                     new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
+                 }
+             }
          }
+         LOG.debug("QoS UUID {} assigned to port not found in operational node {} or QoS updates", qosUuid, ovsdbNode);
+         return SouthboundMapper.createInstanceIdentifier(nodeId)
+                 .augmentation(OvsdbNodeAugmentation.class)
+                 .child(QosEntries.class, new QosEntriesKey(
+                         new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
      }
  
      private void updateOfPort(final Interface interf,
@@@ -475,7 -551,8 +553,7 @@@
                  ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
              }
          } catch (SchemaVersionMismatchException e) {
 -            // We don't care about the exception stack trace here
 -            LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 +            schemaMismatchLog("lldp", "Interface", e);
          }
      }
  
@@@ -518,7 -595,8 +596,7 @@@
                  ovsdbTerminationPointBuilder.setInterfaceBfdStatus(interfaceBfdStatusList);
              }
          } catch (SchemaVersionMismatchException e) {
 -            // We don't care about the exception stack trace here
 -            LOG.debug("bfd-status column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 +            schemaMismatchLog("bfd", "Interface", e);
          }
      }
  
@@@ -542,11 -620,43 +620,43 @@@
                  ovsdbTerminationPointBuilder.setInterfaceBfd(interfaceBfdList);
              }
          } catch (SchemaVersionMismatchException e) {
 -            // We don't care about the exception stack trace here
 -            LOG.debug("bfd column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 +            schemaMismatchLog("bfd", "Interface", e);
 +
          }
      }
  
+     private void updateInterfacePolicing(final Interface interf,
+             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+ 
+         Long ingressPolicingRate = null;
+         if (interf.getIngressPolicingRateColumn() != null) {
+             ingressPolicingRate = interf.getIngressPolicingRateColumn().getData();
+         }
+         if (ingressPolicingRate != null) {
+             if (ingressPolicingRate >= 0) {
+                 ovsdbTerminationPointBuilder
+                     .setIngressPolicingRate(ingressPolicingRate);
+             } else {
+                 LOG.debug("Received negative value for ingressPolicingRate from ovsdb for {} {}",
+                         interf.getName(),ingressPolicingRate);
+             }
+         }
+ 
+         Long ingressPolicingBurst = null;
+         if (interf.getIngressPolicingBurstColumn() != null) {
+             ingressPolicingBurst = interf.getIngressPolicingBurstColumn().getData();
+         }
+         if (ingressPolicingBurst != null) {
+             if (ingressPolicingBurst >= 0) {
+                 ovsdbTerminationPointBuilder
+                     .setIngressPolicingBurst(ingressPolicingBurst);
+             } else {
+                 LOG.debug("Received negative value for ingressPolicingBurst from ovsdb for {} {}",
+                         interf.getName(),ingressPolicingBurst);
+             }
+         }
+     }
+ 
      private boolean portQosCleared(Entry<UUID, Port> portUpdate) {
          if (portUpdate.getValue().getQosColumn() == null) {
              return false;