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