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

   1 /*
   2  * Copyright (c) 2014 Intel Corp. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.ovsdb.southbound.transactions.md;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.Iterator;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18
  19 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  22 import org.opendaylight.ovsdb.lib.error.ColumnSchemaNotFoundException;
  23 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  24 import org.opendaylight.ovsdb.lib.notation.Column;
  25 import org.opendaylight.ovsdb.lib.notation.UUID;
  26 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  27 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  28 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  29 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  30 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  31 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  32 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  33 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  34 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  35 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  58 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  59 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  60 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  64 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  67 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  68 import org.slf4j.Logger;
  69 import org.slf4j.LoggerFactory;
  70
  71 import com.google.common.base.Optional;
  72
  73 public class OvsdbPortUpdateCommand extends AbstractTransactionCommand {
  74     private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
  75     private Map<UUID, Port> portUpdatedRows;
  76     private Map<UUID, Port> portOldRows;
  77     private Map<UUID, Interface> interfaceUpdatedRows;
  78     private Map<UUID, Interface> interfaceOldRows;
  79     private Map<UUID, Bridge> bridgeUpdatedRows;
  80     public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates,
  81             DatabaseSchema dbSchema) {
  82         super(key, updates, dbSchema);
  83         portUpdatedRows = TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema);
  84         portOldRows = TyperUtils.extractRowsOld(Port.class, updates, dbSchema);
  85         interfaceUpdatedRows = TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema);
  86         interfaceOldRows = TyperUtils.extractRowsOld(Interface.class, updates, dbSchema);
  87         bridgeUpdatedRows = TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema);
  88     }
  89
  90     @Override
  91     public void execute(ReadWriteTransaction transaction) {
  92         final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
  93         if ( (portUpdatedRows == null && interfaceOldRows == null )
  94                 || ( interfaceOldRows.isEmpty() && portUpdatedRows.isEmpty())) {
  95             return;
  96         }
  97         Optional<Node> node = readNode(transaction, connectionIId);
  98         if (node.isPresent()) {
  99             updateTerminationPoints(transaction, node.get());
 100         }
 101     }
 102     private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
 103         for (Entry<UUID, Port> portUpdate : portUpdatedRows.entrySet()) {
 104             String portName = null;
 105             portName = portUpdate.getValue().getNameColumn().getData();
 106             Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge(portUpdate.getKey());
 107             if (!bridgeIid.isPresent()) {
 108                 bridgeIid = getTerminationPointBridge( transaction, node, portName);
 109             }
 110             if (bridgeIid.isPresent()) {
 111                 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
 112                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
 113                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 114                 tpBuilder.setKey(tpKey);
 115                 tpBuilder.setTpId(tpKey.getTpId());
 116                 InstanceIdentifier<TerminationPoint> tpPath =
 117                         getInstanceIdentifier(bridgeIid.get(), portUpdate.getValue());
 118                 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 119                         new OvsdbTerminationPointAugmentationBuilder();
 120                 buildTerminationPoint(tpAugmentationBuilder,portUpdate.getValue());
 121                 UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
 122                 if (interfaceUpdatedRows.containsKey(interfaceUUID)) {
 123                     buildTerminationPoint(tpAugmentationBuilder,
 124                             interfaceUpdatedRows.get(interfaceUUID));
 125                     interfaceUpdatedRows.remove(interfaceUUID);
 126                     interfaceOldRows.remove(interfaceUUID);
 127                 }
 128                 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 129                 if (portOldRows.containsKey(portUpdate.getKey())) {
 130                     transaction.merge(LogicalDatastoreType.OPERATIONAL,
 131                             tpPath, tpBuilder.build());
 132                 } else {
 133                     transaction.put(LogicalDatastoreType.OPERATIONAL,
 134                             tpPath, tpBuilder.build());
 135                 }
 136             }
 137         }
 138         for (Entry<UUID, Interface> interfaceUpdate : interfaceUpdatedRows.entrySet()) {
 139             String interfaceName = null;
 140             interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
 141             Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge( transaction, node, interfaceName);
 142             if (bridgeIid.isPresent()) {
 143                 NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
 144                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName));
 145                 InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
 146                         .create(NetworkTopology.class)
 147                         .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 148                         .child(Node.class,new NodeKey(bridgeId))
 149                         .child(TerminationPoint.class,tpKey);
 150                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 151                 tpBuilder.setKey(tpKey);
 152                 tpBuilder.setTpId(tpKey.getTpId());
 153                 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 154                         new OvsdbTerminationPointAugmentationBuilder();
 155                 buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue());
 156                 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 157                 transaction.merge(LogicalDatastoreType.OPERATIONAL,
 158                         tpPath, tpBuilder.build());
 159             }
 160         }
 161
 162     }
 163     private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
 164             Port portUpdate) {
 165
 166         tpAugmentationBuilder
 167                 .setName(portUpdate.getName());
 168         tpAugmentationBuilder.setPortUuid(new Uuid(
 169                 portUpdate.getUuid().toString()));
 170         updatePort(portUpdate, tpAugmentationBuilder);
 171     }
 172
 173     private void buildTerminationPoint(OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
 174             Interface interfaceUpdate) {
 175
 176         tpAugmentationBuilder
 177                 .setName(interfaceUpdate.getName());
 178         tpAugmentationBuilder.setInterfaceUuid(new Uuid(
 179                 interfaceUpdate.getUuid().toString()));
 180         updateInterfaces(interfaceUpdate, tpAugmentationBuilder);
 181     }
 182
 183     private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
 184         Optional<Node> node = Optional.absent();
 185         try {
 186             node = transaction.read(
 187                     LogicalDatastoreType.OPERATIONAL, nodePath)
 188                     .checkedGet();
 189         } catch (final ReadFailedException e) {
 190             LOG.warn("Read Operational/DS for Node fail! {}",
 191                     nodePath, e);
 192         }
 193         return node;
 194     }
 195
 196     private Optional<InstanceIdentifier<Node>> getTerminationPointBridge( UUID portUUID) {
 197         for (UUID bridgeUUID : this.bridgeUpdatedRows.keySet()) {
 198             if (this.bridgeUpdatedRows.get(bridgeUUID).getPortsColumn().getData().contains(portUUID)) {
 199                 return Optional.of(SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
 200                         this.bridgeUpdatedRows.get(bridgeUUID)));
 201             }
 202         }
 203         return Optional.absent();
 204     }
 205     private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
 206             final ReadWriteTransaction transaction, Node node, String tpName) {
 207         OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
 208         List<ManagedNodeEntry> managedNodes = ovsdbNode.getManagedNodeEntry();
 209         for ( ManagedNodeEntry managedNodeEntry : managedNodes ) {
 210             @SuppressWarnings("unchecked")
 211             Node managedNode = readNode(transaction
 212                     ,(InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue()).get();
 213             TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 214             TerminationPointKey tpKey = new TerminationPointKey(new TpId(tpName));
 215             tpBuilder.setKey(tpKey);
 216             if (managedNode.getTerminationPoint().contains(tpBuilder.build())) {
 217                 OvsdbBridgeAugmentation ovsdbNodeAugment
 218                     = managedNode.getAugmentation(OvsdbBridgeAugmentation.class);
 219                 return Optional.of((InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
 220             }
 221         }
 222         return Optional.absent();
 223     }
 224
 225     private void updateInterfaces(Interface interfaceUpdate,
 226             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 227
 228         Column<GenericTableSchema, String> typeColumn = interfaceUpdate.getTypeColumn();
 229         String type = typeColumn.getData();
 230         updateInterface(interfaceUpdate, type,ovsdbTerminationPointBuilder);
 231     }
 232
 233     private void updatePort(final Port port,
 234             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 235
 236         updateVlan(port, ovsdbTerminationPointBuilder);
 237         updateVlanTrunks(port, ovsdbTerminationPointBuilder);
 238         updateVlanMode(port, ovsdbTerminationPointBuilder);
 239         updatePortExternalIds(port, ovsdbTerminationPointBuilder);
 240         updatePortOtherConfig(port, ovsdbTerminationPointBuilder);
 241     }
 242
 243     private void updateInterface(final Interface interf,
 244             final String type,
 245             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 246
 247         ovsdbTerminationPointBuilder.setInterfaceUuid(
 248                 new Uuid(interf.getUuid().toString()));
 249         ovsdbTerminationPointBuilder.setInterfaceType(
 250                 SouthboundMapper.createInterfaceType(type));
 251         updateOfPort(interf, ovsdbTerminationPointBuilder);
 252         updateOfPortRequest(interf, ovsdbTerminationPointBuilder);
 253         updateInterfaceExternalIds(interf, ovsdbTerminationPointBuilder);
 254         updateOptions(interf, ovsdbTerminationPointBuilder);
 255         updateInterfaceOtherConfig(interf, ovsdbTerminationPointBuilder);
 256     }
 257
 258     private void updateVlan(final Port port,
 259             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 260
 261         Collection<Long> vlanId = port.getTagColumn().getData();
 262         if (vlanId.size() > 0) {
 263             Iterator<Long> itr = vlanId.iterator();
 264             // There are no loops here, just get the first element.
 265             int id = itr.next().intValue();
 266             ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
 267         }
 268     }
 269
 270     private void updateVlanTrunks(final Port port,
 271             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 272
 273         Set<Long> portTrunks = port.getTrunksColumn().getData();
 274         List<Trunks> modelTrunks = new ArrayList<Trunks>();
 275         if (!portTrunks.isEmpty()) {
 276             for (Long trunk: portTrunks) {
 277                 if (trunk != null) {
 278                     modelTrunks.add(new TrunksBuilder()
 279                         .setTrunk(new VlanId(trunk.intValue())).build());
 280                 }
 281             }
 282             ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
 283         }
 284     }
 285
 286     private void updateVlanMode(final Port port,
 287             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 288
 289         Collection<String> vlanMode = port.getVlanModeColumn().getData();
 290         if (!vlanMode.isEmpty()) {
 291             Iterator<String> itr = vlanMode.iterator();
 292             String vlanType = itr.next();
 293             if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) {
 294                 ovsdbTerminationPointBuilder
 295                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
 296             } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) {
 297                 ovsdbTerminationPointBuilder
 298                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
 299             } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) {
 300                 ovsdbTerminationPointBuilder
 301                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
 302             } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) {
 303                 ovsdbTerminationPointBuilder
 304                     .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
 305             } else {
 306                 LOG.debug("Invalid vlan mode {}.", vlanType);
 307             }
 308         }
 309     }
 310
 311     private void updateOfPort(final Interface interf,
 312             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 313
 314         Set<Long> ofPorts = interf.getOpenFlowPortColumn().getData();
 315         if (ofPorts != null && !ofPorts.isEmpty()) {
 316             Iterator<Long> ofPortsIter = ofPorts.iterator();
 317             long ofPort = ofPortsIter.next();
 318             if (ofPort >= 0) {
 319                 ovsdbTerminationPointBuilder
 320                     .setOfport(ofPort);
 321             } else {
 322                 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
 323                         interf.getName(),ofPort);
 324             }
 325         }
 326     }
 327
 328     private void updateOfPortRequest(final Interface interf,
 329             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 330
 331         Set<Long> ofPortRequests = null;
 332         try {
 333             ofPortRequests = interf.getOpenFlowPortRequestColumn().getData();
 334         } catch (ColumnSchemaNotFoundException e) {
 335             LOG.warn("Cannot find openflow column", e);
 336         }
 337         if (ofPortRequests != null && !ofPortRequests.isEmpty()) {
 338             Iterator<Long> ofPortRequestsIter = ofPortRequests.iterator();
 339             int ofPort = ofPortRequestsIter.next().intValue();
 340             if (ofPort >= 0) {
 341                 ovsdbTerminationPointBuilder
 342                     .setOfportRequest(ofPort);
 343             } else {
 344                 LOG.debug("Received negative value for ofPort from ovsdb for {} {} {}",
 345                         interf.getName(),ofPort);
 346             }
 347         }
 348     }
 349
 350     private void updateInterfaceExternalIds(final Interface interf,
 351             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 352
 353         Map<String, String> interfaceExternalIds =
 354                 interf.getExternalIdsColumn().getData();
 355         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
 356             Set<String> externalIdKeys = interfaceExternalIds.keySet();
 357             List<InterfaceExternalIds> externalIdsList =
 358                     new ArrayList<InterfaceExternalIds>();
 359             String externalIdValue;
 360             for (String externalIdKey : externalIdKeys) {
 361                 externalIdValue = interfaceExternalIds.get(externalIdKey);
 362                 if (externalIdKey != null && externalIdValue != null) {
 363                     externalIdsList.add(new InterfaceExternalIdsBuilder()
 364                             .setExternalIdKey(externalIdKey)
 365                             .setExternalIdValue(externalIdValue).build());
 366                 }
 367             }
 368             ovsdbTerminationPointBuilder.setInterfaceExternalIds(externalIdsList);
 369         }
 370     }
 371
 372     private void updatePortExternalIds(final Port port,
 373             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 374
 375         Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
 376         if (portExternalIds != null && !portExternalIds.isEmpty()) {
 377             Set<String> externalIdKeys = portExternalIds.keySet();
 378             List<PortExternalIds> externalIdsList = new ArrayList<PortExternalIds>();
 379             String externalIdValue;
 380             for (String externalIdKey : externalIdKeys) {
 381                 externalIdValue = portExternalIds.get(externalIdKey);
 382                 if (externalIdKey != null && externalIdValue != null) {
 383                     externalIdsList.add(new PortExternalIdsBuilder()
 384                             .setExternalIdKey(externalIdKey)
 385                             .setExternalIdValue(externalIdValue).build());
 386                 }
 387             }
 388             ovsdbTerminationPointBuilder.setPortExternalIds(externalIdsList);
 389         }
 390     }
 391
 392     private void updateOptions(final Interface interf,
 393             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 394
 395         Map<String, String> optionsMap = interf.getOptionsColumn().getData();
 396         if (optionsMap != null && !optionsMap.isEmpty()) {
 397             List<Options> options = new ArrayList<Options>();
 398             String optionsValueString;
 399             OptionsKey optionsKey;
 400             for (String optionsKeyString : optionsMap.keySet()) {
 401                 optionsValueString = optionsMap.get(optionsKeyString);
 402                 if (optionsKeyString != null && optionsValueString != null) {
 403                     optionsKey = new OptionsKey(optionsKeyString);
 404                     options.add(new OptionsBuilder()
 405                         .setKey(optionsKey)
 406                         .setValue(optionsValueString).build());
 407                 }
 408             }
 409             ovsdbTerminationPointBuilder.setOptions(options);
 410         }
 411     }
 412
 413     private void updatePortOtherConfig(final Port port,
 414             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 415
 416         Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
 417         if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
 418             List<PortOtherConfigs> portOtherConfigs = new ArrayList<PortOtherConfigs>();
 419             String portOtherConfigValueString;
 420             for (String portOtherConfigKeyString : portOtherConfigMap.keySet()) {
 421                 portOtherConfigValueString = portOtherConfigMap.get(portOtherConfigKeyString);
 422                 if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
 423                     portOtherConfigs.add(new PortOtherConfigsBuilder()
 424                         .setOtherConfigKey(portOtherConfigKeyString)
 425                         .setOtherConfigValue(portOtherConfigValueString).build());
 426                 }
 427             }
 428             ovsdbTerminationPointBuilder.setPortOtherConfigs(portOtherConfigs);
 429         }
 430     }
 431
 432     private void updateInterfaceOtherConfig(final Interface interf,
 433             final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
 434
 435         Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
 436         if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
 437             List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<InterfaceOtherConfigs>();
 438             String interfaceOtherConfigValueString;
 439             for (String interfaceOtherConfigKeyString : interfaceOtherConfigMap.keySet()) {
 440                 interfaceOtherConfigValueString = interfaceOtherConfigMap.get(interfaceOtherConfigKeyString);
 441                 if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
 442                     interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
 443                         .setOtherConfigKey(interfaceOtherConfigKeyString)
 444                         .setOtherConfigValue(interfaceOtherConfigValueString).build());
 445                 }
 446             }
 447             ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(interfaceOtherConfigs);
 448         }
 449     }
 450
 451     private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
 452         if (port.getExternalIdsColumn() != null
 453                 && port.getExternalIdsColumn().getData() != null
 454                 && port.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
 455             String iidString = port.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY);
 456             return (InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(iidString);
 457         } else {
 458             return bridgeIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(port.getName())));
 459         }
 460     }
 461 }