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.southbound.OvsdbConnectionInstance;
  34 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  35 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  36 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldpKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  64 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  71 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  72 import org.slf4j.Logger;
  73 import org.slf4j.LoggerFactory;
  74
  75 import com.google.common.base.Optional;
  76
  77 public class OvsdbPortUpdateCommand extends AbstractTransactionCommand {
  78     private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
  79     private Map<UUID, Port> portUpdatedRows;
  80     private Map<UUID, Port> portOldRows;
  81     private Map<UUID, Interface> interfaceUpdatedRows;
  82     private Map<UUID, Interface> interfaceOldRows;
  83     private Map<UUID, Bridge> bridgeUpdatedRows;
  84     public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates,
  85             DatabaseSchema dbSchema) {
  86         super(key, updates, dbSchema);
  87         portUpdatedRows = TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema);
  88         portOldRows = TyperUtils.extractRowsOld(Port.class, updates, dbSchema);
  89         interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema);
  90         interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema);
  91         bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema);
  92     }
  93
  94     @Override
  95     public void execute(ReadWriteTransaction transaction) {
  96         final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
  97         if ( (portUpdatedRows == null && interfaceOldRows == null )
  98                 || ( interfaceOldRows.isEmpty() && portUpdatedRows.isEmpty())) {
  99             return;
 100         }
 101         Optional<Node> node = readNode(transaction, connectionIId);
 102         if (node.isPresent()) {
 103             updateTerminationPoints(transaction, node.get());
 104         }
 105     }
 106     private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
 107         for (Entry<UUID, Port> portUpdate : portUpdatedRows.entrySet()) {
 108             String portName = null;
 109             portName = portUpdate.getValue().getNameColumn().getData();
 110             Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge(portUpdate.getKey());
 111             if (!bridgeIid.isPresent()) {
 112                 bridgeIid = getTerminationPointBridge( transaction, node, portName);
 113             }
 114             if (bridgeIid.isPresent()) {
 115                 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
 116                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
 117                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 118                 tpBuilder.setKey(tpKey);
 119                 tpBuilder.setTpId(tpKey.getTpId());
 120                 InstanceIdentifier<TerminationPoint> tpPath =
 121                         getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue());
 122                 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 123                         new OvsdbTerminationPointAugmentationBuilder();
 124                 buildTerminationPoint(tpAugmentationBuilder,portUpdate.getValue());
 125                 UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
 126                 if (interfaceUpdatedRows.containsKey(interfaceUUID)) {
 127                     buildTerminationPoint(tpAugmentationBuilder,
 128                             interfaceUpdatedRows.get(interfaceUUID));
 129                     interfaceUpdatedRows.remove(interfaceUUID);
 130                     interfaceOldRows.remove(interfaceUUID);
 131                 }
 132                 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 133                 if (portOldRows.containsKey(portUpdate.getKey()) && !portQosCleared(portUpdate)) {
 134                     transaction.merge(LogicalDatastoreType.OPERATIONAL,
 135                             tpPath, tpBuilder.build());
 136                 } else {
 137                     transaction.put(LogicalDatastoreType.OPERATIONAL,
 138                             tpPath, tpBuilder.build());
 139                 }
 140             }
 141         }
 142         for (Entry<UUID, Interface> interfaceUpdate : interfaceUpdatedRows.entrySet()) {
 143             String interfaceName = null;
 144             interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
 145             Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge( transaction, node, interfaceName);
 146             if (bridgeIid.isPresent()) {
 147                 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
 148                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName));
 149                 InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
 150                         .create(NetworkTopology.class)
 151                         .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 152                         .child(Node.class,new NodeKey(bridgeId))
 153                         .child(TerminationPoint.class,tpKey);
 154                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 155                 tpBuilder.setKey(tpKey);
 156                 tpBuilder.setTpId(tpKey.getTpId());
 157                 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 158                         new OvsdbTerminationPointAugmentationBuilder();
 159                 buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue());
 160                 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 161                 transaction.merge(LogicalDatastoreType.OPERATIONAL,
 162                         tpPath, tpBuilder.build());
 163             }
 164         }
 165
 166     }
 167     private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
 168             Port portUpdate) {
 169
 170         tpAugmentationBuilder
 171                 .setName(portUpdate.getName());
 172         tpAugmentationBuilder.setPortUuid(new Uuid(
 173                 portUpdate.getUuid().toString()));
 174         updatePort(portUpdate, tpAugmentationBuilder);
 175     }
 176
 177     private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
 178             Interface interfaceUpdate) {
 179
 180         tpAugmentationBuilder
 181                 .setName(interfaceUpdate.getName());
 182         tpAugmentationBuilder.setInterfaceUuid(new Uuid(
 183                 interfaceUpdate.getUuid().toString()));
 184         updateInterfaces(interfaceUpdate, tpAugmentationBuilder);
 185     }
 186
 187     private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
 188         Optional<Node> node = Optional.absent();
 189         try {
 190             node = transaction.read(
 191                     LogicalDatastoreType.OPERATIONAL, nodePath)
 192                     .checkedGet();
 193         } catch (final ReadFailedException e) {
 194             LOG.warn("Read Operational/DS for Node fail! {}",
 195                     nodePath, e);
 196         }
 197         return node;
 198     }
 199
 200     private Optional<InstanceIdentifier<Node>> getTerminationPointBridge( UUID portUUID) {
 201         for (UUID bridgeUUID : this.bridgeUpdatedRows.keySet()) {
 202             if (this.bridgeUpdatedRows.get(bridgeUUID).getPortsColumn().getData().contains(portUUID)) {
 203                 return Optional.of(SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
 204                         this.bridgeUpdatedRows.get(bridgeUUID)));
 205             }
 206         }
 207         return Optional.absent();
 208     }
 209     private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
 210             final ReadWriteTransaction transaction, Node node, String tpName) {
 211         OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
 212         List<ManagedNodeEntry> managedNodes = ovsdbNode.getManagedNodeEntry();
 213         for ( ManagedNodeEntry managedNodeEntry : managedNodes ) {
 214             @SuppressWarnings("unchecked")
 215             Node managedNode = readNode(transaction
 216                     ,(InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue()).get();
 217             TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 218             TerminationPointKey tpKey = new TerminationPointKey(new TpId(tpName));
 219             tpBuilder.setKey(tpKey);
 220             if (managedNode.getTerminationPoint().contains(tpBuilder.build())) {
 221                 OvsdbBridgeAugmentation ovsdbNodeAugment
 222                     = managedNode.getAugmentation(OvsdbBridgeAugmentation.class);
 223                 return Optional.of((InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
 224             }
 225         }
 226         return Optional.absent();
 227     }
 228
 229     private void updateInterfaces(Interface interfaceUpdate,
 230             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 231
 232         Column<GenericTableSchema, String> typeColumn = interfaceUpdate.getTypeColumn();
 233         String type = typeColumn.getData();
 234         updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
 235     }
 236
 237     private void updatePort(final Port port,
 238             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 239
 240         updateVlan(port, ovsdbTerminationPointBuilder);
 241         updateVlanTrunks(port, ovsdbTerminationPointBuilder);
 242         updateVlanMode(port, ovsdbTerminationPointBuilder);
 243         updateQos(port, ovsdbTerminationPointBuilder);
 244         updatePortExternalIds(port, ovsdbTerminationPointBuilder);
 245         updatePortOtherConfig(port, ovsdbTerminationPointBuilder);
 246     }
 247
 248     private void updateInterface(final Interface interf,
 249             final String type,
 250             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 251
 252         ovsdbTerminationPointBuilder.setInterfaceUuid(
 253                 new Uuid(interf.getUuid().toString()));
 254         ovsdbTerminationPointBuilder.setInterfaceType(
 255                 SouthboundMapper.createInterfaceType(type));
 256         updateOfPort(interf, ovsdbTerminationPointBuilder);
 257         updateOfPortRequest(interf, ovsdbTerminationPointBuilder);
 258         updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder);
 259         updateOptions(interf, ovsdbTerminationPointBuilder);
 260         updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder);
 261         updateInterfaceLldp(interf, ovsdbTerminationPointBuilder);
 262     }
 263
 264     private void updateVlan(final Port port,
 265             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 266
 267         Collection<Long> vlanId = port.getTagColumn().getData();
 268         if (vlanId.size() > 0) {
 269             Iterator<Long> itr = vlanId.iterator();
 270             // There are no loops here, just get the first element.
 271             int id = itr.next().intValue();
 272             ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
 273         }
 274     }
 275
 276     private void updateVlanTrunks(final Port port,
 277             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 278
 279         Set<Long> portTrunks = port.getTrunksColumn().getData();
 280         List<Trunks> modelTrunks = new ArrayList<>();
 281         if (!portTrunks.isEmpty()) {
 282             for (Long trunk: portTrunks) {
 283                 if (trunk != null) {
 284                     modelTrunks.add(new TrunksBuilder()
 285                         .setTrunk(new VlanId(trunk.intValue())).build());
 286                 }
 287             }
 288             ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
 289         }
 290     }
 291
 292     private void updateVlanMode(final Port port,
 293             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 294
 295         Collection<String> vlanMode = port.getVlanModeColumn().getData();
 296         if (!vlanMode.isEmpty()) {
 297             Iterator<String> itr = vlanMode.iterator();
 298             String vlanType = itr.next();
 299             if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) {
 300                 ovsdbTerminationPointBuilder
 301                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
 302             } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) {
 303                 ovsdbTerminationPointBuilder
 304                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
 305             } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) {
 306                 ovsdbTerminationPointBuilder
 307                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
 308             } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) {
 309                 ovsdbTerminationPointBuilder
 310                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
 311             } else {
 312                 LOG.debug("Invalid vlan mode {}.", vlanType);
 313             }
 314         }
 315     }
 316
 317     private void updateQos(final Port port,
 318             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 319         if (port.getQosColumn() == null) {
 320             return;
 321         }
 322         Collection<UUID> qosUuidCol = port.getQosColumn().getData();
 323         if (!qosUuidCol.isEmpty()) {
 324             Iterator<UUID> itr = qosUuidCol.iterator();
 325             UUID qosUuid = itr.next();
 326             ovsdbTerminationPointBuilder.setQos(new Uuid(qosUuid.toString()));
 327         }
 328     }
 329
 330     private void updateOfPort(final Interface interf,
 331             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 332
 333         Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
 334         if (ofPorts != null && !ofPorts.isEmpty()) {
 335             Iterator<Long> ofPortsIter = ofPorts.iterator();
 336             long ofPort = ofPortsIter.next();
 337             if (ofPort >= 0) {
 338                 ovsdbTerminationPointBuilder
 339                     .setOfport(ofPort);
 340             } else {
 341                 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
 342                         interf.getName(),ofPort);
 343             }
 344         }
 345     }
 346
 347     private void updateOfPortRequest(final Interface interf,
 348             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 349
 350         Set<Long> ofPortRequests = null;
 351         try {
 352             ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
 353         } catch (ColumnSchemaNotFoundException e) {
 354             LOG.warn("Cannot find openflow column", e);
 355         }
 356         if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
 357             Iterator<Long> ofPortRequestsIter = ofPortRequests.iterator();
 358             int ofPort = ofPortRequestsIter.next().intValue();
 359             if (ofPort >= 0) {
 360                 ovsdbTerminationPointBuilder
 361                     .setOfportRequest(ofPort);
 362             } else {
 363                 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
 364                         interf.getName(),ofPort);
 365             }
 366         }
 367     }
 368
 369     private void updateInterfaceExternalIds(final Interface interf,
 370             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 371
 372         Map<String, String> interfaceExternalIds =
 373                 interf.getExternalIdsColumn().getData();
 374         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
 375             Set<String> externalIdKeys = interfaceExternalIds.keySet();
 376             List<InterfaceExternalIds> externalIdsList =
 377                     new ArrayList<>();
 378             String externalIdValue;
 379             for (String externalIdKey : externalIdKeys) {
 380                 externalIdValue = interfaceExternalIds.get(externalIdKey);
 381                 if (externalIdKey != null && externalIdValue != null) {
 382                     externalIdsList.add(new InterfaceExternalIdsBuilder()
 383                             .setExternalIdKey(externalIdKey)
 384                             .setExternalIdValue(externalIdValue).build());
 385                 }
 386             }
 387             ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList);
 388         }
 389     }
 390
 391     private void updatePortExternalIds(final Port port,
 392             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 393
 394         Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
 395         if (portExternalIds != null && !portExternalIds.isEmpty()) {
 396             Set<String> externalIdKeys = portExternalIds.keySet();
 397             List<PortExternalIds> externalIdsList = new ArrayList<>();
 398             String externalIdValue;
 399             for (String externalIdKey : externalIdKeys) {
 400                 externalIdValue = portExternalIds.get(externalIdKey);
 401                 if (externalIdKey != null && externalIdValue != null) {
 402                     externalIdsList.add(new PortExternalIdsBuilder()
 403                             .setExternalIdKey(externalIdKey)
 404                             .setExternalIdValue(externalIdValue).build());
 405                 }
 406             }
 407             ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList);
 408         }
 409     }
 410
 411     private void updateOptions(final Interface interf,
 412             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 413
 414         Map<String, String> optionsMap = interf.getOptionsColumn().getData();
 415         if (optionsMap != null && !optionsMap.isEmpty()) {
 416             List<Options> options = new ArrayList<>();
 417             String optionsValueString;
 418             OptionsKey optionsKey;
 419             for (String optionsKeyString : optionsMap.keySet()) {
 420                 optionsValueString = optionsMap.get(optionsKeyString);
 421                 if (optionsKeyString != null && optionsValueString != null) {
 422                     optionsKey = new OptionsKey(optionsKeyString);
 423                     options.add(new OptionsBuilder()
 424                         .setKey(optionsKey)
 425                         .setValue(optionsValueString).build());
 426                 }
 427             }
 428             ovsdbTerminationPointBuilder.setOptions(options);
 429         }
 430     }
 431
 432     private void updatePortOtherConfig(final Port port,
 433             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 434
 435         Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
 436         if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
 437             List<PortOtherConfigs> portOtherConfigs = new ArrayList<>();
 438             String portOtherConfigValueString;
 439             for (String portOtherConfigKeyString : portOtherConfigMap.keySet()) {
 440                 portOtherConfigValueString = portOtherConfigMap.get(portOtherConfigKeyString);
 441                 if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
 442                     portOtherConfigs.add(new PortOtherConfigsBuilder()
 443                         .setOtherConfigKey(portOtherConfigKeyString)
 444                         .setOtherConfigValue(portOtherConfigValueString).build());
 445                 }
 446             }
 447             ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs);
 448         }
 449     }
 450
 451     private void updateInterfaceLldp(final Interface interf,
 452             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 453
 454         try {
 455             Map<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
 456             if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
 457                 List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
 458                 for (String interfaceLldpKeyString : interfaceLldpMap.keySet()) {
 459                     String interfaceLldpValueString = interfaceLldpMap.get(interfaceLldpKeyString);
 460                     if (interfaceLldpKeyString != null && interfaceLldpValueString!=null) {
 461                         interfaceLldpList.add(new InterfaceLldpBuilder()
 462                                 .setKey(new InterfaceLldpKey(interfaceLldpKeyString))
 463                                 .setLldpKey(interfaceLldpKeyString)
 464                                 .setLldpValue(interfaceLldpValueString)
 465                                 .build());
 466                     }
 467                 }
 468                 ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
 469             }
 470         } catch (SchemaVersionMismatchException e) {
 471             // We don't care about the exception stack trace here
 472             LOG.debug("lldp column for Interface Table unsupported for this version of ovsdb schema. {}", e.getMessage());
 473         }
 474     }
 475
 476     private void updateInterfaceOtherConfig(final Interface interf,
 477             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 478
 479         Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
 480         if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
 481             List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<>();
 482             String interfaceOtherConfigValueString;
 483             for (String interfaceOtherConfigKeyString : interfaceOtherConfigMap.keySet()) {
 484                 interfaceOtherConfigValueString = interfaceOtherConfigMap.get(interfaceOtherConfigKeyString);
 485                 if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
 486                     interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
 487                         .setOtherConfigKey(interfaceOtherConfigKeyString)
 488                         .setOtherConfigValue(interfaceOtherConfigValueString).build());
 489                 }
 490             }
 491             ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
 492         }
 493     }
 494
 495     private boolean portQosCleared(Entry<UUID, Port> portUpdate) {
 496         if (portUpdate.getValue().getQosColumn() == null) {
 497             return false;
 498         }
 499         Collection<UUID> newQos = portUpdate.getValue().getQosColumn().getData();
 500         if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) {
 501             return false;
 502         }
 503         Collection<UUID> oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData();
 504
 505         if (newQos.isEmpty() && !oldQos.isEmpty()) {
 506             return true;
 507         } else {
 508             return false;
 509         }
 510     }
 511
 512     private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
 513         if (port.getExternalIdsColumn() != null
 514                 && port.getExternalIdsColumn().getData() != null
 515                 && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
 516             String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY);
 517             return (InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(iidString);
 518         } else {
 519             return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));
 520         }
 521     }
 522 }