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