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

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