southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommand.java

   1 /*
   2  * Copyright (c) 2014 Intel Corp. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.ovsdb.southbound.transactions.md;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.Iterator;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18
  19 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  22 import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException;
  23 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
  24 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  25 import org.opendaylight.ovsdb.lib.notation.Column;
  26 import org.opendaylight.ovsdb.lib.notation.UUID;
  27 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  28 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  29 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  30 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  31 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  32 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  33 import org.opendaylight.ovsdb.schema.openvswitch.Qos;
  34 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  35 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  36 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  37 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdKey;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntry;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.QosEntryKey;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  75 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  78 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  79 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  84 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  85 import org.slf4j.Logger;
  86 import org.slf4j.LoggerFactory;
  87
  88 import com.google.common.base.Optional;
  89
  90 public class OvsdbPortUpdateCommand extends AbstractTransactionCommand {
  91     private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
  92     private Map<UUID, Port> portUpdatedRows;
  93     private Map<UUID, Port> portOldRows;
  94     private Map<UUID, Interface> interfaceUpdatedRows;
  95     private Map<UUID, Interface> interfaceOldRows;
  96     private Map<UUID, Bridge> bridgeUpdatedRows;
  97     private Map<UUID, Qos> qosUpdatedRows;
  98     public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates,
  99             DatabaseSchema dbSchema) {
 100         super(key, updates, dbSchema);
 101         portUpdatedRows = TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema);
 102         portOldRows = TyperUtils.extractRowsOld(Port.class, updates, dbSchema);
 103         interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema);
 104         interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema);
 105         bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema);
 106         qosUpdatedRows = TyperUtils.extractRowsUpdated(Qos.class, updates, dbSchema);
 107     }
 108
 109     @Override
 110     public void execute(ReadWriteTransaction transaction) {
 111         final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
 112         if ( (portUpdatedRows == null && interfaceOldRows == null )
 113                 || ( interfaceOldRows.isEmpty() && portUpdatedRows.isEmpty())) {
 114             return;
 115         }
 116         Optional<Node> node = readNode(transaction, connectionIId);
 117         if (node.isPresent()) {
 118             updateTerminationPoints(transaction, node.get());
 119         }
 120     }
 121     private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
 122         for (Entry<UUID, Port> portUpdate : portUpdatedRows.entrySet()) {
 123             String portName = null;
 124             portName = portUpdate.getValue().getNameColumn().getData();
 125             Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge(portUpdate.getKey());
 126             if (!bridgeIid.isPresent()) {
 127                 bridgeIid = getTerminationPointBridge( transaction, node, portName);
 128             }
 129             if (bridgeIid.isPresent()) {
 130                 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
 131                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
 132                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 133                 tpBuilder.setKey(tpKey);
 134                 tpBuilder.setTpId(tpKey.getTpId());
 135                 InstanceIdentifier<TerminationPoint> tpPath =
 136                         getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue());
 137                 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 138                         new OvsdbTerminationPointAugmentationBuilder();
 139                 buildTerminationPoint(transaction, tpPath, tpAugmentationBuilder, node, portUpdate);
 140                 UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
 141                 if (interfaceUpdatedRows.containsKey(interfaceUUID)) {
 142                     buildTerminationPoint(tpAugmentationBuilder,
 143                             interfaceUpdatedRows.get(interfaceUUID));
 144                     interfaceUpdatedRows.remove(interfaceUUID);
 145                     interfaceOldRows.remove(interfaceUUID);
 146                 }
 147                 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 148                 if (portOldRows.containsKey(portUpdate.getKey()) && !portQosCleared(portUpdate)) {
 149                     transaction.merge(LogicalDatastoreType.OPERATIONAL,
 150                             tpPath, tpBuilder.build());
 151                 } else {
 152                     transaction.put(LogicalDatastoreType.OPERATIONAL,
 153                             tpPath, tpBuilder.build());
 154                 }
 155             }
 156         }
 157         for (Entry<UUID, Interface> interfaceUpdate : interfaceUpdatedRows.entrySet()) {
 158             String interfaceName = null;
 159             interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
 160             Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge( transaction, node, interfaceName);
 161             if (bridgeIid.isPresent()) {
 162                 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
 163                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName));
 164                 InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
 165                         .create(NetworkTopology.class)
 166                         .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 167                         .child(Node.class,new NodeKey(bridgeId))
 168                         .child(TerminationPoint.class,tpKey);
 169                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 170                 tpBuilder.setKey(tpKey);
 171                 tpBuilder.setTpId(tpKey.getTpId());
 172                 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 173                         new OvsdbTerminationPointAugmentationBuilder();
 174                 buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue());
 175                 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 176                 transaction.merge(LogicalDatastoreType.OPERATIONAL,
 177                         tpPath, tpBuilder.build());
 178             }
 179         }
 180
 181     }
 182     private void buildTerminationPoint(ReadWriteTransaction transaction,
 183             InstanceIdentifier<TerminationPoint> tpPath,
 184             OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
 185             Node node, Entry<UUID, Port> portUpdate) {
 186
 187         tpAugmentationBuilder
 188                 .setName(portUpdate.getValue().getName());
 189         tpAugmentationBuilder.setPortUuid(new Uuid(
 190                 portUpdate.getValue().getUuid().toString()));
 191         updatePort(transaction, node, tpPath, portUpdate, tpAugmentationBuilder);
 192     }
 193
 194     private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
 195             Interface interfaceUpdate) {
 196
 197         tpAugmentationBuilder
 198                 .setName(interfaceUpdate.getName());
 199         tpAugmentationBuilder.setInterfaceUuid(new Uuid(
 200                 interfaceUpdate.getUuid().toString()));
 201         updateInterfaces(interfaceUpdate, tpAugmentationBuilder);
 202     }
 203
 204     private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
 205         Optional<Node> node = Optional.absent();
 206         try {
 207             node = transaction.read(
 208                     LogicalDatastoreType.OPERATIONAL, nodePath)
 209                     .checkedGet();
 210         } catch (final ReadFailedException e) {
 211             LOG.warn("Read Operational/DS for Node fail! {}",
 212                     nodePath, e);
 213         }
 214         return node;
 215     }
 216
 217     private Optional<InstanceIdentifier<Node>> getTerminationPointBridge( UUID portUUID) {
 218         for (UUID bridgeUUID : this.bridgeUpdatedRows.keySet()) {
 219             if (this.bridgeUpdatedRows.get(bridgeUUID).getPortsColumn().getData().contains(portUUID)) {
 220                 return Optional.of(SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
 221                         this.bridgeUpdatedRows.get(bridgeUUID)));
 222             }
 223         }
 224         return Optional.absent();
 225     }
 226     private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
 227             final ReadWriteTransaction transaction, Node node, String tpName) {
 228         OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
 229         List<ManagedNodeEntry> managedNodes = ovsdbNode.getManagedNodeEntry();
 230         TpId tpId = new TpId(tpName);
 231         for ( ManagedNodeEntry managedNodeEntry : managedNodes ) {
 232             @SuppressWarnings("unchecked")
 233             Node managedNode = readNode(transaction
 234                     ,(InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue()).get();
 235             for (TerminationPoint tpEntry : managedNode.getTerminationPoint()) {
 236                 if (tpId.equals(tpEntry.getTpId())) {
 237                     return Optional.of((InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
 238                 }
 239             }
 240         }
 241         return Optional.absent();
 242     }
 243
 244     private void updateInterfaces(Interface interfaceUpdate,
 245             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 246
 247         Column<GenericTableSchema, String> typeColumn = interfaceUpdate.getTypeColumn();
 248         String type = typeColumn.getData();
 249         updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
 250     }
 251
 252     private void updatePort(final ReadWriteTransaction transaction, final Node node,
 253             final InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
 254             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 255
 256         updateVlan(port.getValue(), ovsdbTerminationPointBuilder);
 257         updateVlanTrunks(port.getValue(), ovsdbTerminationPointBuilder);
 258         updateVlanMode(port.getValue(), ovsdbTerminationPointBuilder);
 259         updateQos(transaction, node, tpPath, port, ovsdbTerminationPointBuilder);
 260         updatePortExternalIds(port.getValue(), ovsdbTerminationPointBuilder);
 261         updatePortOtherConfig(port.getValue(), ovsdbTerminationPointBuilder);
 262     }
 263
 264     private void updateInterface(final Interface interf,
 265             final String type,
 266             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 267
 268         ovsdbTerminationPointBuilder.setInterfaceUuid(
 269                 new Uuid(interf.getUuid().toString()));
 270         ovsdbTerminationPointBuilder.setInterfaceType(
 271                 SouthboundMapper.createInterfaceType(type));
 272         updateOfPort(interf, ovsdbTerminationPointBuilder);
 273         updateOfPortRequest(interf, ovsdbTerminationPointBuilder);
 274         updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder);
 275         updateOptions(interf, ovsdbTerminationPointBuilder);
 276         updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder);
 277         updateInterfaceLldp(interf, ovsdbTerminationPointBuilder);
 278         updateInterfaceBfd(interf, ovsdbTerminationPointBuilder);
 279         updateInterfaceBfdStatus(interf, ovsdbTerminationPointBuilder);
 280         updateInterfacePolicing(interf, ovsdbTerminationPointBuilder);
 281     }
 282
 283     private void updateVlan(final Port port,
 284             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 285
 286         Collection<Long> vlanId = port.getTagColumn().getData();
 287         if (vlanId.size() > 0) {
 288             Iterator<Long> itr = vlanId.iterator();
 289             // There are no loops here, just get the first element.
 290             int id = itr.next().intValue();
 291             ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
 292         }
 293     }
 294
 295     private void updateVlanTrunks(final Port port,
 296             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 297
 298         Set<Long> portTrunks = port.getTrunksColumn().getData();
 299         List<Trunks> modelTrunks = new ArrayList<>();
 300         if (!portTrunks.isEmpty()) {
 301             for (Long trunk: portTrunks) {
 302                 if (trunk != null) {
 303                     modelTrunks.add(new TrunksBuilder()
 304                         .setTrunk(new VlanId(trunk.intValue())).build());
 305                 }
 306             }
 307             ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
 308         }
 309     }
 310
 311     private void updateVlanMode(final Port port,
 312             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 313
 314         Collection<String> vlanMode = port.getVlanModeColumn().getData();
 315         if (!vlanMode.isEmpty()) {
 316             Iterator<String> itr = vlanMode.iterator();
 317             String vlanType = itr.next();
 318             if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) {
 319                 ovsdbTerminationPointBuilder
 320                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
 321             } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) {
 322                 ovsdbTerminationPointBuilder
 323                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
 324             } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) {
 325                 ovsdbTerminationPointBuilder
 326                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
 327             } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) {
 328                 ovsdbTerminationPointBuilder
 329                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
 330             } else {
 331                 LOG.debug("Invalid vlan mode {}.", vlanType);
 332             }
 333         }
 334     }
 335
 336     private void updateQos(final ReadWriteTransaction transaction, final Node node, InstanceIdentifier<TerminationPoint> tpPath,
 337             final Entry<UUID, Port> port, final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 338         if (port.getValue() == null) {
 339             return;
 340         }
 341         Collection<UUID> qosUuidCol = port.getValue().getQosColumn().getData();
 342         if (!qosUuidCol.isEmpty()) {
 343             UUID qosUuid = qosUuidCol.iterator().next();
 344             ovsdbTerminationPointBuilder.setQos(new Uuid(qosUuid.toString()));
 345
 346             NodeId nodeId = node.getNodeId();
 347             OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
 348
 349             // Delete an older QoS entry
 350             if (portOldRows.containsKey(port.getKey()) &&
 351                     portOldRows.get(port.getKey()).getQosColumn() != null) {
 352                 Collection<UUID> oldQos = portOldRows.get(port.getKey()).getQosColumn().getData();
 353                 if (!oldQos.isEmpty()) {
 354                     UUID oldQosUuid = oldQos.iterator().next();
 355                     if (!oldQosUuid.equals(qosUuid)) {
 356                         InstanceIdentifier<QosEntries> oldQosIid = getQosIid(nodeId, ovsdbNode, oldQosUuid);
 357                         if (oldQosIid != null) {
 358                             InstanceIdentifier<QosEntry> oldPortQosIid = tpPath
 359                                 .augmentation(OvsdbTerminationPointAugmentation.class)
 360                                 .child(QosEntry.class,
 361                                       new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY)));
 362 //                                    new QosEntryKey(new OvsdbQosRef(oldQosIid)));
 363                             transaction.delete(LogicalDatastoreType.OPERATIONAL, oldPortQosIid);
 364                         }
 365                     }
 366                 }
 367             }
 368
 369             InstanceIdentifier<QosEntries> qosIid = getQosIid(nodeId, ovsdbNode, qosUuid);
 370             if (qosIid != null) {
 371                 List<QosEntry> qosList = new ArrayList<>();
 372                 OvsdbQosRef qosRef = new OvsdbQosRef(qosIid);
 373                 qosList.add(new QosEntryBuilder()
 374                     .setKey(new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY)))
 375                     .setQosRef(qosRef).build());
 376                 ovsdbTerminationPointBuilder.setQosEntry(qosList);
 377             }
 378         }
 379     }
 380
 381     private InstanceIdentifier<QosEntries> getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) {
 382         // Search for the QoS entry first in the operational datastore
 383         for (QosEntries qosEntry : ovsdbNode.getQosEntries()) {
 384             if (qosEntry.getQosUuid().equals(new Uuid(qosUuid.toString()))) {
 385                 return SouthboundMapper.createInstanceIdentifier(nodeId)
 386                         .augmentation(OvsdbNodeAugmentation.class)
 387                         .child(QosEntries.class, new QosEntriesKey(qosEntry.getQosId()));
 388             }
 389         }
 390
 391         // Search for the QoS entry in the current OVS updates
 392         for (Entry<UUID, Qos> qosUpdate : qosUpdatedRows.entrySet()) {
 393             Qos qos = qosUpdate.getValue();
 394             if (qos.getUuid().equals(qosUuid)) {
 395                 if (qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
 396                     return (InstanceIdentifier<QosEntries>) SouthboundUtil.deserializeInstanceIdentifier(
 397                             qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
 398                 } else {
 399                     return SouthboundMapper.createInstanceIdentifier(nodeId)
 400                             .augmentation(OvsdbNodeAugmentation.class)
 401                             .child(QosEntries.class, new QosEntriesKey(
 402                                     new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
 403                 }
 404             }
 405         }
 406         LOG.debug("QoS UUID {} assigned to port not found in operational node {} or QoS updates", qosUuid, ovsdbNode);
 407         return SouthboundMapper.createInstanceIdentifier(nodeId)
 408                 .augmentation(OvsdbNodeAugmentation.class)
 409                 .child(QosEntries.class, new QosEntriesKey(
 410                         new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
 411     }
 412
 413     private void updateOfPort(final Interface interf,
 414             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 415
 416         Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
 417         if (ofPorts != null && !ofPorts.isEmpty()) {
 418             Iterator<Long> ofPortsIter = ofPorts.iterator();
 419             long ofPort = ofPortsIter.next();
 420             if (ofPort >= 0) {
 421                 ovsdbTerminationPointBuilder
 422                     .setOfport(ofPort);
 423             } else {
 424                 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
 425                         interf.getName(),ofPort);
 426             }
 427         }
 428     }
 429
 430     private void updateOfPortRequest(final Interface interf,
 431             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 432
 433         Set<Long> ofPortRequests = null;
 434         try {
 435             ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
 436         } catch (ColumnSchemaNotFoundException e) {
 437             LOG.warn("Cannot find openflow column", e);
 438         }
 439         if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
 440             Iterator<Long> ofPortRequestsIter = ofPortRequests.iterator();
 441             int ofPort = ofPortRequestsIter.next().intValue();
 442             if (ofPort >= 0) {
 443                 ovsdbTerminationPointBuilder
 444                     .setOfportRequest(ofPort);
 445             } else {
 446                 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
 447                         interf.getName(),ofPort);
 448             }
 449         }
 450     }
 451
 452     private void updateInterfaceExternalIds(final Interface interf,
 453             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 454
 455         Map<String, String> interfaceExternalIds =
 456                 interf.getExternalIdsColumn().getData();
 457         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
 458             Set<String> externalIdKeys = interfaceExternalIds.keySet();
 459             List<InterfaceExternalIds> externalIdsList =
 460                     new ArrayList<>();
 461             String externalIdValue;
 462             for (String externalIdKey : externalIdKeys) {
 463                 externalIdValue = interfaceExternalIds.get(externalIdKey);
 464                 if (externalIdKey != null && externalIdValue != null) {
 465                     externalIdsList.add(new InterfaceExternalIdsBuilder()
 466                             .setExternalIdKey(externalIdKey)
 467                             .setExternalIdValue(externalIdValue).build());
 468                 }
 469             }
 470             ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList);
 471         }
 472     }
 473
 474     private void updatePortExternalIds(final Port port,
 475             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 476
 477         Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
 478         if (portExternalIds != null && !portExternalIds.isEmpty()) {
 479             Set<String> externalIdKeys = portExternalIds.keySet();
 480             List<PortExternalIds> externalIdsList = new ArrayList<>();
 481             String externalIdValue;
 482             for (String externalIdKey : externalIdKeys) {
 483                 externalIdValue = portExternalIds.get(externalIdKey);
 484                 if (externalIdKey != null && externalIdValue != null) {
 485                     externalIdsList.add(new PortExternalIdsBuilder()
 486                             .setExternalIdKey(externalIdKey)
 487                             .setExternalIdValue(externalIdValue).build());
 488                 }
 489             }
 490             ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList);
 491         }
 492     }
 493
 494     private void updateOptions(final Interface interf,
 495             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 496
 497         Map<String, String> optionsMap = interf.getOptionsColumn().getData();
 498         if (optionsMap != null && !optionsMap.isEmpty()) {
 499             List<Options> options = new ArrayList<>();
 500             String optionsValueString;
 501             OptionsKey optionsKey;
 502             for (String optionsKeyString : optionsMap.keySet()) {
 503                 optionsValueString = optionsMap.get(optionsKeyString);
 504                 if (optionsKeyString != null && optionsValueString != null) {
 505                     optionsKey = new OptionsKey(optionsKeyString);
 506                     options.add(new OptionsBuilder()
 507                         .setKey(optionsKey)
 508                         .setValue(optionsValueString).build());
 509                 }
 510             }
 511             ovsdbTerminationPointBuilder.setOptions(options);
 512         }
 513     }
 514
 515     private void updatePortOtherConfig(final Port port,
 516             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 517
 518         Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
 519         if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
 520             List<PortOtherConfigs> portOtherConfigs = new ArrayList<>();
 521             String portOtherConfigValueString;
 522             for (String portOtherConfigKeyString : portOtherConfigMap.keySet()) {
 523                 portOtherConfigValueString = portOtherConfigMap.get(portOtherConfigKeyString);
 524                 if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
 525                     portOtherConfigs.add(new PortOtherConfigsBuilder()
 526                         .setOtherConfigKey(portOtherConfigKeyString)
 527                         .setOtherConfigValue(portOtherConfigValueString).build());
 528                 }
 529             }
 530             ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs);
 531         }
 532     }
 533
 534     private void updateInterfaceLldp(final Interface interf,
 535             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 536
 537         try {
 538             Map<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
 539             if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
 540                 List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
 541                 for (String interfaceLldpKeyString : interfaceLldpMap.keySet()) {
 542                     String interfaceLldpValueString = interfaceLldpMap.get(interfaceLldpKeyString);
 543                     if (interfaceLldpKeyString != null && interfaceLldpValueString!=null) {
 544                         interfaceLldpList.add(new InterfaceLldpBuilder()
 545                                 .setKey(new InterfaceLldpKey(interfaceLldpKeyString))
 546                                 .setLldpKey(interfaceLldpKeyString)
 547                                 .setLldpValue(interfaceLldpValueString)
 548                                 .build());
 549                     }
 550                 }
 551                 ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
 552             }
 553         } catch (SchemaVersionMismatchException e) {
 554             // We don't care about the exception stack trace here
 555             LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 556         }
 557     }
 558
 559     private void updateInterfaceOtherConfig(final Interface interf,
 560             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 561
 562         Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
 563         if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
 564             List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<>();
 565             String interfaceOtherConfigValueString;
 566             for (String interfaceOtherConfigKeyString : interfaceOtherConfigMap.keySet()) {
 567                 interfaceOtherConfigValueString = interfaceOtherConfigMap.get(interfaceOtherConfigKeyString);
 568                 if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
 569                     interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
 570                         .setOtherConfigKey(interfaceOtherConfigKeyString)
 571                         .setOtherConfigValue(interfaceOtherConfigValueString).build());
 572                 }
 573             }
 574             ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
 575         }
 576     }
 577
 578     private void updateInterfaceBfdStatus(final Interface interf,
 579             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 580
 581         try {
 582             Map<String, String> interfaceBfdStatusMap = interf.getBfdStatusColumn().getData();
 583             if (interfaceBfdStatusMap != null && !interfaceBfdStatusMap.isEmpty()) {
 584                 List<InterfaceBfdStatus> interfaceBfdStatusList = new ArrayList<>();
 585                 for (String interfaceBfdStatusKeyString : interfaceBfdStatusMap.keySet()) {
 586                     String interfaceBfdStatusValueString = interfaceBfdStatusMap.get(interfaceBfdStatusKeyString);
 587                     if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString!=null) {
 588                         interfaceBfdStatusList.add(new InterfaceBfdStatusBuilder()
 589                                 .setKey(new InterfaceBfdStatusKey(interfaceBfdStatusKeyString))
 590                                 .setBfdStatusKey(interfaceBfdStatusKeyString)
 591                                 .setBfdStatusValue(interfaceBfdStatusValueString)
 592                                 .build());
 593                     }
 594                 }
 595                 ovsdbTerminationPointBuilder.setInterfaceBfdStatus(interfaceBfdStatusList);
 596             }
 597         } catch (SchemaVersionMismatchException e) {
 598             // We don't care about the exception stack trace here
 599             LOG.debug("bfd-status column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 600         }
 601     }
 602
 603     private void updateInterfaceBfd(final Interface interf,
 604             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 605
 606         try {
 607             Map<String, String> interfaceBfdMap = interf.getBfdColumn().getData();
 608             if (interfaceBfdMap != null && !interfaceBfdMap.isEmpty()) {
 609                 List<InterfaceBfd> interfaceBfdList = new ArrayList<>();
 610                 for (String interfaceBfdKeyString : interfaceBfdMap.keySet()) {
 611                     String interfaceBfdValueString = interfaceBfdMap.get(interfaceBfdKeyString);
 612                     if (interfaceBfdKeyString != null && interfaceBfdValueString!=null) {
 613                         interfaceBfdList.add(new InterfaceBfdBuilder()
 614                                 .setKey(new InterfaceBfdKey(interfaceBfdKeyString))
 615                                 .setBfdKey(interfaceBfdKeyString)
 616                                 .setBfdValue(interfaceBfdValueString)
 617                                 .build());
 618                     }
 619                 }
 620                 ovsdbTerminationPointBuilder.setInterfaceBfd(interfaceBfdList);
 621             }
 622         } catch (SchemaVersionMismatchException e) {
 623             // We don't care about the exception stack trace here
 624             LOG.debug("bfd column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 625         }
 626     }
 627
 628     private void updateInterfacePolicing(final Interface interf,
 629             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 630
 631         Long ingressPolicingRate = null;
 632         if (interf.getIngressPolicingRateColumn() != null) {
 633             ingressPolicingRate = interf.getIngressPolicingRateColumn().getData();
 634         }
 635         if (ingressPolicingRate != null) {
 636             if (ingressPolicingRate >= 0) {
 637                 ovsdbTerminationPointBuilder
 638                     .setIngressPolicingRate(ingressPolicingRate);
 639             } else {
 640                 LOG.debug("Received negative value for ingressPolicingRate from ovsdb for {} {}",
 641                         interf.getName(),ingressPolicingRate);
 642             }
 643         }
 644
 645         Long ingressPolicingBurst = null;
 646         if (interf.getIngressPolicingBurstColumn() != null) {
 647             ingressPolicingBurst = interf.getIngressPolicingBurstColumn().getData();
 648         }
 649         if (ingressPolicingBurst != null) {
 650             if (ingressPolicingBurst >= 0) {
 651                 ovsdbTerminationPointBuilder
 652                     .setIngressPolicingBurst(ingressPolicingBurst);
 653             } else {
 654                 LOG.debug("Received negative value for ingressPolicingBurst from ovsdb for {} {}",
 655                         interf.getName(),ingressPolicingBurst);
 656             }
 657         }
 658     }
 659
 660     private boolean portQosCleared(Entry<UUID, Port> portUpdate) {
 661         if (portUpdate.getValue().getQosColumn() == null) {
 662             return false;
 663         }
 664         Collection<UUID> newQos = portUpdate.getValue().getQosColumn().getData();
 665         if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) {
 666             return false;
 667         }
 668         Collection<UUID> oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData();
 669
 670         if (newQos.isEmpty() && !oldQos.isEmpty()) {
 671             return true;
 672         } else {
 673             return false;
 674         }
 675     }
 676
 677     private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
 678         if (port.getExternalIdsColumn() != null
 679                 && port.getExternalIdsColumn().getData() != null
 680                 && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
 681             String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY);
 682             return (InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(iidString);
 683         } else {
 684             return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));
 685         }
 686     }
 687 }