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
 244         for (ManagedNodeEntry managedNodeEntry : managedNodes) {
 245             Optional<Node> optManagedNode = readNode(transaction,
 246                     (InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
 247             if (optManagedNode.isPresent()) {
 248                 Node managedNode = optManagedNode.get();
 249                 List<TerminationPoint> tpEntrys = managedNode.getTerminationPoint();
 250                 if (tpEntrys != null) {
 251                     for (TerminationPoint tpEntry : tpEntrys) {
 252                         if (tpId.equals(tpEntry.getTpId())) {
 253                             return Optional.of((InstanceIdentifier<Node>) managedNodeEntry.getBridgeRef().getValue());
 254                         }
 255                     }
 256                 }
 257             }
 258         }
 259
 260         return Optional.absent();
 261     }
 262
 263     @VisibleForTesting
 264     void updateInterfaces(Interface interfaceUpdate,
 265             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 266
 267         Column<GenericTableSchema, String> typeColumn = interfaceUpdate.getTypeColumn();
 268         String type = typeColumn.getData();
 269         updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
 270     }
 271
 272     @VisibleForTesting
 273     void updatePort(final ReadWriteTransaction transaction, final Node node,
 274             final InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
 275             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 276
 277         updateVlan(port.getValue(), ovsdbTerminationPointBuilder);
 278         updateVlanTrunks(port.getValue(), ovsdbTerminationPointBuilder);
 279         updateVlanMode(port.getValue(), ovsdbTerminationPointBuilder);
 280         updateQos(transaction, node, tpPath, port, ovsdbTerminationPointBuilder);
 281         updatePortExternalIds(port.getValue(), ovsdbTerminationPointBuilder);
 282         updatePortOtherConfig(port.getValue(), ovsdbTerminationPointBuilder);
 283     }
 284
 285     @VisibleForTesting
 286     void updateInterface(final Interface interf,
 287             final String type,
 288             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 289
 290         ovsdbTerminationPointBuilder.setInterfaceUuid(
 291                 new Uuid(interf.getUuid().toString()));
 292         ovsdbTerminationPointBuilder.setInterfaceType(
 293                 SouthboundMapper.createInterfaceType(type));
 294         updateIfIndex(interf, ovsdbTerminationPointBuilder);
 295         updateMac(interf, ovsdbTerminationPointBuilder);
 296         updateMacInUse(interf, ovsdbTerminationPointBuilder);
 297         updateOfPort(interf, ovsdbTerminationPointBuilder);
 298         updateOfPortRequest(interf, ovsdbTerminationPointBuilder);
 299         updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder);
 300         updateOptions(interf, ovsdbTerminationPointBuilder);
 301         updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder);
 302         updateInterfaceLldp(interf, ovsdbTerminationPointBuilder);
 303         updateInterfaceBfd(interf, ovsdbTerminationPointBuilder);
 304         updateInterfaceBfdStatus(interf, ovsdbTerminationPointBuilder);
 305         updateInterfacePolicing(interf, ovsdbTerminationPointBuilder);
 306     }
 307
 308     @VisibleForTesting
 309     void updateVlan(final Port port,
 310             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 311
 312         Collection<Long> vlanId = port.getTagColumn().getData();
 313         if (vlanId.size() > 0) {
 314             Iterator<Long> itr = vlanId.iterator();
 315             // There are no loops here, just get the first element.
 316             int id = itr.next().intValue();
 317             ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
 318         }
 319     }
 320
 321     @VisibleForTesting
 322     void updateVlanTrunks(final Port port,
 323             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 324
 325         Set<Long> portTrunks = port.getTrunksColumn().getData();
 326         List<Trunks> modelTrunks = new ArrayList<>();
 327         if (!portTrunks.isEmpty()) {
 328             for (Long trunk: portTrunks) {
 329                 if (trunk != null) {
 330                     modelTrunks.add(new TrunksBuilder()
 331                         .setTrunk(new VlanId(trunk.intValue())).build());
 332                 }
 333             }
 334         }
 335         ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
 336     }
 337
 338     @VisibleForTesting
 339     void updateVlanMode(final Port port,
 340             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 341
 342         Collection<String> vlanMode = port.getVlanModeColumn().getData();
 343         if (!vlanMode.isEmpty()) {
 344             Iterator<String> itr = vlanMode.iterator();
 345             String vlanType = itr.next();
 346             if (vlanType.equals(SouthboundConstants.VlanModes.ACCESS.getMode())) {
 347                 ovsdbTerminationPointBuilder
 348                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
 349             } else if (vlanType.equals(SouthboundConstants.VlanModes.NATIVE_TAGGED.getMode())) {
 350                 ovsdbTerminationPointBuilder
 351                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
 352             } else if (vlanType.equals(SouthboundConstants.VlanModes.NATIVE_UNTAGGED.getMode())) {
 353                 ovsdbTerminationPointBuilder
 354                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
 355             } else if (vlanType.equals(SouthboundConstants.VlanModes.TRUNK.getMode())) {
 356                 ovsdbTerminationPointBuilder
 357                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
 358             } else {
 359                 LOG.debug("Invalid vlan mode {}.", vlanType);
 360             }
 361         }
 362     }
 363
 364     private void updateQos(final ReadWriteTransaction transaction, final Node node,
 365                            InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
 366                            final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 367         if (port.getValue() == null) {
 368             return;
 369         }
 370         Collection<UUID> qosUuidCol = port.getValue().getQosColumn().getData();
 371         if (!qosUuidCol.isEmpty()) {
 372             UUID qosUuid = qosUuidCol.iterator().next();
 373
 374             NodeId nodeId = node.getNodeId();
 375             OvsdbNodeAugmentation ovsdbNode = node.augmentation(OvsdbNodeAugmentation.class);
 376
 377             // Delete an older QoS entry
 378             if (portOldRows.containsKey(port.getKey()) && portOldRows.get(port.getKey()).getQosColumn() != null) {
 379                 Collection<UUID> oldQos = portOldRows.get(port.getKey()).getQosColumn().getData();
 380                 if (!oldQos.isEmpty()) {
 381                     UUID oldQosUuid = oldQos.iterator().next();
 382                     if (!oldQosUuid.equals(qosUuid)) {
 383                         InstanceIdentifier<QosEntries> oldQosIid = getQosIid(nodeId, ovsdbNode, oldQosUuid);
 384                         if (oldQosIid != null) {
 385                             InstanceIdentifier<QosEntry> oldPortQosIid = tpPath
 386                                 .augmentation(OvsdbTerminationPointAugmentation.class)
 387                                 .child(QosEntry.class,
 388                                       new QosEntryKey(Long.valueOf(SouthboundConstants.PORT_QOS_LIST_KEY)));
 389                             transaction.delete(LogicalDatastoreType.OPERATIONAL, oldPortQosIid);
 390                         }
 391                     }
 392                 }
 393             }
 394
 395             InstanceIdentifier<QosEntries> qosIid = getQosIid(nodeId, ovsdbNode, qosUuid);
 396             if (qosIid != null) {
 397                 List<QosEntry> qosList = new ArrayList<>();
 398                 OvsdbQosRef qosRef = new OvsdbQosRef(qosIid);
 399                 qosList.add(new QosEntryBuilder()
 400                     .withKey(new QosEntryKey(Long.valueOf(SouthboundConstants.PORT_QOS_LIST_KEY)))
 401                     .setQosRef(qosRef).build());
 402                 ovsdbTerminationPointBuilder.setQosEntry(qosList);
 403             }
 404         }
 405     }
 406
 407     @SuppressWarnings("unchecked")
 408     private InstanceIdentifier<QosEntries> getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) {
 409         // Search for the QoS entry first in the operational datastore
 410         for (QosEntries qosEntry : ovsdbNode.getQosEntries()) {
 411             if (qosEntry.getQosUuid().equals(new Uuid(qosUuid.toString()))) {
 412                 return SouthboundMapper.createInstanceIdentifier(nodeId)
 413                         .augmentation(OvsdbNodeAugmentation.class)
 414                         .child(QosEntries.class, new QosEntriesKey(qosEntry.getQosId()));
 415             }
 416         }
 417
 418         // Search for the QoS entry in the current OVS updates
 419         for (Entry<UUID, Qos> qosUpdate : qosUpdatedRows.entrySet()) {
 420             Qos qos = qosUpdate.getValue();
 421             if (qos.getUuid().equals(qosUuid)) {
 422                 if (qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
 423                     return (InstanceIdentifier<QosEntries>) instanceIdentifierCodec.bindingDeserializerOrNull(
 424                             qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
 425                 } else {
 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         }
 433         LOG.debug("QoS UUID {} assigned to port not found in operational node {} or QoS updates", qosUuid, ovsdbNode);
 434         return SouthboundMapper.createInstanceIdentifier(nodeId)
 435                 .augmentation(OvsdbNodeAugmentation.class)
 436                 .child(QosEntries.class, new QosEntriesKey(
 437                         new Uri(SouthboundConstants.QOS_URI_PREFIX + "://" + qosUuid.toString())));
 438     }
 439
 440     private void updateIfIndex(final Interface interf,
 441             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 442         Set<Long> ifIndexSet = null;
 443         try {
 444             if (interf.getIfIndexColumn() != null) {
 445                 ifIndexSet = interf.getIfIndexColumn().getData();
 446             }
 447             if (ifIndexSet != null && !ifIndexSet.isEmpty()) {
 448                 for (Long ifIndex : ifIndexSet) {
 449                     ovsdbTerminationPointBuilder.setIfindex(ifIndex);
 450                 }
 451             }
 452         } catch (SchemaVersionMismatchException e) {
 453             schemaMismatchLog("ifindex", "Interface", e);
 454         }
 455     }
 456
 457     private void updateMac(final Interface interf,
 458                            final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 459         Set<String> macSet = null;
 460         try {
 461             if (interf.getMacColumn() != null) {
 462                 macSet = interf.getMacColumn().getData();
 463             }
 464             if (macSet != null && !macSet.isEmpty()) {
 465                 /*
 466                  * It is a set due to way JSON decoder converts [] objects. OVS
 467                  * only supports ONE mac, so we're fine.
 468                  */
 469                 for (String mac: macSet) {
 470                     ovsdbTerminationPointBuilder.setMac(new MacAddress(mac));
 471                 }
 472             }
 473         } catch (SchemaVersionMismatchException e) {
 474             schemaMismatchLog("mac", "Interface", e);
 475         }
 476     }
 477
 478     private void updateMacInUse(final Interface interf,
 479                                final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 480         Set<String> macInUseSet = null;
 481         try {
 482             if (interf.getMacInUseColumn() != null) {
 483                 macInUseSet = interf.getMacInUseColumn().getData();
 484             }
 485             if (macInUseSet != null && !macInUseSet.isEmpty()) {
 486                 /*
 487                  * It is a set due to way JSON decoder converts [] objects. OVS
 488                  * only supports ONE mac, so we're fine.
 489                  */
 490                 for (String macInUse: macInUseSet) {
 491                     ovsdbTerminationPointBuilder.setMacInUse(new MacAddress(macInUse));
 492                 }
 493             }
 494         } catch (SchemaVersionMismatchException e) {
 495             schemaMismatchLog("mac_in_use", "Interface", e);
 496         }
 497     }
 498
 499     @VisibleForTesting
 500     void updateOfPort(final Interface interf,
 501             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 502
 503         Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
 504         if (ofPorts != null && !ofPorts.isEmpty()) {
 505             Iterator<Long> ofPortsIter = ofPorts.iterator();
 506             long ofPort = ofPortsIter.next();
 507             if (ofPort >= 0) {
 508                 ovsdbTerminationPointBuilder
 509                     .setOfport(ofPort);
 510             } else {
 511                 LOG.debug("Received negative value for ofPort from ovsdb for {} {}",
 512                         interf.getName(),ofPort);
 513             }
 514         }
 515     }
 516
 517     @VisibleForTesting
 518     void updateOfPortRequest(final Interface interf,
 519             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 520
 521         Set<Long> ofPortRequests = null;
 522         try {
 523             ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
 524         } catch (ColumnSchemaNotFoundException e) {
 525             LOG.warn("Cannot find openflow column", e);
 526         }
 527         if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
 528             Iterator<Long> ofPortRequestsIter = ofPortRequests.iterator();
 529             int ofPort = ofPortRequestsIter.next().intValue();
 530             if (ofPort >= 0) {
 531                 ovsdbTerminationPointBuilder
 532                     .setOfportRequest(ofPort);
 533             } else {
 534                 LOG.debug("Received negative value for ofPort from ovsdb for {} {}",
 535                         interf.getName(),ofPort);
 536             }
 537         }
 538     }
 539
 540     @VisibleForTesting
 541     void updateInterfaceExternalIds(final Interface interf,
 542             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 543
 544         Map<String, String> interfaceExternalIds =
 545                 interf.getExternalIdsColumn().getData();
 546         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
 547             List<InterfaceExternalIds> externalIdsList = new ArrayList<>();
 548             for (Entry<String, String> entry : interfaceExternalIds.entrySet()) {
 549                 String externalIdKey = entry.getKey();
 550                 String externalIdValue = entry.getValue();
 551                 if (externalIdKey != null && externalIdValue != null) {
 552                     externalIdsList.add(new InterfaceExternalIdsBuilder()
 553                             .setExternalIdKey(externalIdKey)
 554                             .setExternalIdValue(externalIdValue).build());
 555                 }
 556             }
 557             ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList);
 558         }
 559     }
 560
 561     @VisibleForTesting
 562     void updatePortExternalIds(final Port port,
 563             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 564
 565         Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
 566         if (portExternalIds != null && !portExternalIds.isEmpty()) {
 567             List<PortExternalIds> externalIdsList = new ArrayList<>();
 568             for (Entry<String, String> entry : portExternalIds.entrySet()) {
 569                 String externalIdKey = entry.getKey();
 570                 String externalIdValue = entry.getValue();
 571                 if (externalIdKey != null && externalIdValue != null) {
 572                     externalIdsList.add(new PortExternalIdsBuilder()
 573                             .setExternalIdKey(externalIdKey)
 574                             .setExternalIdValue(externalIdValue).build());
 575                 }
 576             }
 577             ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList);
 578         }
 579     }
 580
 581     @VisibleForTesting
 582     void updateOptions(final Interface interf,
 583             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 584
 585         Map<String, String> optionsMap = interf.getOptionsColumn().getData();
 586         if (optionsMap != null && !optionsMap.isEmpty()) {
 587             List<Options> options = new ArrayList<>();
 588             for (Entry<String, String> entry : optionsMap.entrySet()) {
 589                 String optionsKeyString = entry.getKey();
 590                 String optionsValueString = entry.getValue();
 591                 if (optionsKeyString != null && optionsValueString != null) {
 592                     OptionsKey optionsKey = new OptionsKey(optionsKeyString);
 593                     options.add(new OptionsBuilder()
 594                         .withKey(optionsKey)
 595                         .setValue(optionsValueString).build());
 596                 }
 597             }
 598             ovsdbTerminationPointBuilder.setOptions(options);
 599         }
 600     }
 601
 602     @VisibleForTesting
 603     void updatePortOtherConfig(final Port port,
 604             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 605
 606         Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
 607         if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
 608             List<PortOtherConfigs> portOtherConfigs = new ArrayList<>();
 609             for (Entry<String, String> entry : portOtherConfigMap.entrySet()) {
 610                 String portOtherConfigKeyString = entry.getKey();
 611                 String portOtherConfigValueString = entry.getValue();
 612                 if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
 613                     portOtherConfigs.add(new PortOtherConfigsBuilder()
 614                         .setOtherConfigKey(portOtherConfigKeyString)
 615                         .setOtherConfigValue(portOtherConfigValueString).build());
 616                 }
 617             }
 618             ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs);
 619         }
 620     }
 621
 622     private void updateInterfaceLldp(final Interface interf,
 623             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 624
 625         try {
 626             Map<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
 627             if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
 628                 List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
 629                 for (Entry<String, String> entry : interfaceLldpMap.entrySet()) {
 630                     String interfaceLldpKeyString = entry.getKey();
 631                     String interfaceLldpValueString = entry.getValue();
 632                     if (interfaceLldpKeyString != null && interfaceLldpValueString != null) {
 633                         interfaceLldpList.add(new InterfaceLldpBuilder()
 634                                 .withKey(new InterfaceLldpKey(interfaceLldpKeyString))
 635                                 .setLldpKey(interfaceLldpKeyString)
 636                                 .setLldpValue(interfaceLldpValueString)
 637                                 .build());
 638                     }
 639                 }
 640                 ovsdbTerminationPointBuilder.setInterfaceLldp(interfaceLldpList);
 641             }
 642         } catch (SchemaVersionMismatchException e) {
 643             schemaMismatchLog("lldp", "Interface", e);
 644         }
 645     }
 646
 647     @VisibleForTesting
 648     void updateInterfaceOtherConfig(final Interface interf,
 649             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 650
 651         Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
 652         if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
 653             List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<>();
 654             for (Entry<String, String> entry : interfaceOtherConfigMap.entrySet()) {
 655                 String interfaceOtherConfigKeyString = entry.getKey();
 656                 String interfaceOtherConfigValueString = entry.getValue();
 657                 if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
 658                     interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
 659                         .setOtherConfigKey(interfaceOtherConfigKeyString)
 660                         .setOtherConfigValue(interfaceOtherConfigValueString).build());
 661                 }
 662             }
 663             ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
 664         }
 665     }
 666
 667     private void updateInterfaceBfdStatus(final Interface interf,
 668             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 669
 670         try {
 671             Map<String, String> interfaceBfdStatusMap = interf.getBfdStatusColumn().getData();
 672             if (interfaceBfdStatusMap != null && !interfaceBfdStatusMap.isEmpty()) {
 673                 List<InterfaceBfdStatus> interfaceBfdStatusList = new ArrayList<>();
 674                 for (Entry<String, String> entry : interfaceBfdStatusMap.entrySet()) {
 675                     String interfaceBfdStatusKeyString = entry.getKey();
 676                     String interfaceBfdStatusValueString = entry.getValue();
 677                     if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString != null) {
 678                         interfaceBfdStatusList.add(new InterfaceBfdStatusBuilder()
 679                                 .withKey(new InterfaceBfdStatusKey(interfaceBfdStatusKeyString))
 680                                 .setBfdStatusKey(interfaceBfdStatusKeyString)
 681                                 .setBfdStatusValue(interfaceBfdStatusValueString)
 682                                 .build());
 683                     }
 684                 }
 685                 ovsdbTerminationPointBuilder.setInterfaceBfdStatus(interfaceBfdStatusList);
 686             }
 687         } catch (SchemaVersionMismatchException e) {
 688             schemaMismatchLog("bfd", "Interface", e);
 689         }
 690     }
 691
 692     private void updateInterfaceBfd(final Interface interf,
 693             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 694
 695         try {
 696             Map<String, String> interfaceBfdMap = interf.getBfdColumn().getData();
 697             if (interfaceBfdMap != null && !interfaceBfdMap.isEmpty()) {
 698                 List<InterfaceBfd> interfaceBfdList = new ArrayList<>();
 699                 for (Entry<String, String> entry : interfaceBfdMap.entrySet()) {
 700                     String interfaceBfdKeyString = entry.getKey();
 701                     String interfaceBfdValueString = entry.getValue();
 702                     if (interfaceBfdKeyString != null && interfaceBfdValueString != null) {
 703                         interfaceBfdList.add(new InterfaceBfdBuilder()
 704                                 .withKey(new InterfaceBfdKey(interfaceBfdKeyString))
 705                                 .setBfdKey(interfaceBfdKeyString)
 706                                 .setBfdValue(interfaceBfdValueString)
 707                                 .build());
 708                     }
 709                 }
 710                 ovsdbTerminationPointBuilder.setInterfaceBfd(interfaceBfdList);
 711             }
 712         } catch (SchemaVersionMismatchException e) {
 713             schemaMismatchLog("bfd", "Interface", e);
 714
 715         }
 716     }
 717
 718     private void updateInterfacePolicing(final Interface interf,
 719             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 720
 721         Long ingressPolicingRate = null;
 722         if (interf.getIngressPolicingRateColumn() != null) {
 723             ingressPolicingRate = interf.getIngressPolicingRateColumn().getData();
 724         }
 725         if (ingressPolicingRate != null) {
 726             if (ingressPolicingRate >= 0) {
 727                 ovsdbTerminationPointBuilder
 728                     .setIngressPolicingRate(ingressPolicingRate);
 729             } else {
 730                 LOG.debug("Received negative value for ingressPolicingRate from ovsdb for {} {}",
 731                         interf.getName(),ingressPolicingRate);
 732             }
 733         }
 734
 735         Long ingressPolicingBurst = null;
 736         if (interf.getIngressPolicingBurstColumn() != null) {
 737             ingressPolicingBurst = interf.getIngressPolicingBurstColumn().getData();
 738         }
 739         if (ingressPolicingBurst != null) {
 740             if (ingressPolicingBurst >= 0) {
 741                 ovsdbTerminationPointBuilder
 742                     .setIngressPolicingBurst(ingressPolicingBurst);
 743             } else {
 744                 LOG.debug("Received negative value for ingressPolicingBurst from ovsdb for {} {}",
 745                         interf.getName(),ingressPolicingBurst);
 746             }
 747         }
 748     }
 749
 750     private boolean portQosCleared(Entry<UUID, Port> portUpdate) {
 751         if (portUpdate.getValue().getQosColumn() == null) {
 752             return false;
 753         }
 754         Collection<UUID> newQos = portUpdate.getValue().getQosColumn().getData();
 755         if (portOldRows.get(portUpdate.getKey()).getQosColumn() == null) {
 756             return false;
 757         }
 758         Collection<UUID> oldQos = portOldRows.get(portUpdate.getKey()).getQosColumn().getData();
 759
 760         if (newQos.isEmpty() && !oldQos.isEmpty()) {
 761             return true;
 762         } else {
 763             return false;
 764         }
 765     }
 766
 767     @SuppressWarnings("unchecked")
 768     @VisibleForTesting
 769     InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
 770         if (port.getExternalIdsColumn() != null
 771                 && port.getExternalIdsColumn().getData() != null
 772                 && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
 773             String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY);
 774             return (InstanceIdentifier<TerminationPoint>) instanceIdentifierCodec.bindingDeserializerOrNull(iidString);
 775         } else {
 776             return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));
 777         }
 778     }
 779 }