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