utils/southbound-utils/src/main/java/org/opendaylight/ovsdb/utils/southbound/utils/SouthboundUtils.java

   1 /*
   2  * Copyright (c) 2015 Red Hat, Inc. 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.utils.southbound.utils;
  10
  11 import com.google.common.collect.ImmutableBiMap;
  12 import java.net.InetAddress;
  13 import java.net.UnknownHostException;
  14 import java.util.ArrayList;
  15
  16 import java.util.List;
  17 import java.util.Map;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  20 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  21 import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  40 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  41 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  44 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  45 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  46 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  47 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  49 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  50 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  52 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55
  56 public class SouthboundUtils {
  57     private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtils.class);
  58     private static final int OVSDB_UPDATE_TIMEOUT = 1000;
  59     private static final String DEFAULT_OPENFLOW_PORT = "6653";
  60     private static final String OPENFLOW_CONNECTION_PROTOCOL = "tcp";
  61     private MdsalUtils mdsalUtils;
  62     public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
  63
  64     public SouthboundUtils(MdsalUtils mdsalUtils) {
  65         this.mdsalUtils = mdsalUtils;
  66     }
  67
  68     public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP
  69             = new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
  70             .put("internal", InterfaceTypeInternal.class)
  71             .put("vxlan", InterfaceTypeVxlan.class)
  72             .put("patch", InterfaceTypePatch.class)
  73             .put("system", InterfaceTypeSystem.class)
  74             .put("tap", InterfaceTypeTap.class)
  75             .put("geneve", InterfaceTypeGeneve.class)
  76             .put("gre", InterfaceTypeGre.class)
  77             .put("ipsec_gre", InterfaceTypeIpsecGre.class)
  78             .put("gre64", InterfaceTypeGre64.class)
  79             .put("ipsec_gre64", InterfaceTypeIpsecGre64.class)
  80             .put("lisp", InterfaceTypeLisp.class)
  81             .put("dpdk", InterfaceTypeDpdk.class)
  82             .put("dpdkr", InterfaceTypeDpdkr.class)
  83             .put("dpdkvhost", InterfaceTypeDpdkvhost.class)
  84             .put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.class)
  85             .build();
  86
  87     public NodeId createNodeId(IpAddress ip, PortNumber port) {
  88         String uriString = SouthboundConstants.OVSDB_URI_PREFIX + "://"
  89                 + String.valueOf(ip.getValue()) + ":" + port.getValue();
  90         Uri uri = new Uri(uriString);
  91         return new NodeId(uri);
  92     }
  93
  94     public Node createNode(ConnectionInfo key) {
  95         NodeBuilder nodeBuilder = new NodeBuilder();
  96         nodeBuilder.setNodeId(createNodeId(key.getRemoteIp(), key.getRemotePort()));
  97         nodeBuilder.addAugmentation(OvsdbNodeAugmentation.class, createOvsdbAugmentation(key));
  98         return nodeBuilder.build();
  99     }
 100
 101     public OvsdbNodeAugmentation createOvsdbAugmentation(ConnectionInfo key) {
 102         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
 103         ovsdbNodeBuilder.setConnectionInfo(key);
 104         return ovsdbNodeBuilder.build();
 105     }
 106
 107     public InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key) {
 108         return createInstanceIdentifier(key.getRemoteIp(), key.getRemotePort());
 109     }
 110
 111     public InstanceIdentifier<Node> createInstanceIdentifier(IpAddress ip, PortNumber port) {
 112         InstanceIdentifier<Node> path = InstanceIdentifier
 113                 .create(NetworkTopology.class)
 114                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 115                 .child(Node.class,createNodeKey(ip,port));
 116         LOG.debug("Created ovsdb path: {}",path);
 117         return path;
 118     }
 119
 120     public InstanceIdentifier<Node> createInstanceIdentifier(ConnectionInfo key,OvsdbBridgeName bridgeName) {
 121         return SouthboundMapper.createInstanceIdentifier(createManagedNodeId(key, bridgeName));
 122     }
 123
 124     public InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(Node node, String portName){
 125
 126         InstanceIdentifier<TerminationPoint> terminationPointPath = InstanceIdentifier
 127                 .create(NetworkTopology.class)
 128                 .child(Topology.class, new TopologyKey(OVSDB_TOPOLOGY_ID))
 129                 .child(Node.class,node.getKey())
 130                 .child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
 131
 132         LOG.debug("Termination point InstanceIdentifier generated : {}",terminationPointPath);
 133         return terminationPointPath;
 134     }
 135
 136     public NodeKey createNodeKey(IpAddress ip, PortNumber port) {
 137         return new NodeKey(createNodeId(ip, port));
 138     }
 139
 140     public NodeId createManagedNodeId(ConnectionInfo key, OvsdbBridgeName bridgeName) {
 141         return createManagedNodeId(key.getRemoteIp(), key.getRemotePort(), bridgeName);
 142     }
 143
 144     public NodeId createManagedNodeId(IpAddress ip, PortNumber port, OvsdbBridgeName bridgeName) {
 145         return new NodeId(createNodeId(ip,port).getValue()
 146                 + "/" + SouthboundConstants.BRIDGE_URI_PREFIX + "/" + bridgeName.getValue());
 147     }
 148
 149     public ConnectionInfo getConnectionInfo(final String addressStr, final String portStr) {
 150         InetAddress inetAddress = null;
 151         try {
 152             inetAddress = InetAddress.getByName(addressStr);
 153         } catch (UnknownHostException e) {
 154             LOG.warn("Could not allocate InetAddress");
 155         }
 156
 157         IpAddress address = SouthboundMapper.createIpAddress(inetAddress);
 158         PortNumber port = new PortNumber(Integer.parseInt(portStr));
 159
 160         LOG.info("connectionInfo: {}", new ConnectionInfoBuilder()
 161                 .setRemoteIp(address)
 162                 .setRemotePort(port)
 163                 .build());
 164         return new ConnectionInfoBuilder()
 165                 .setRemoteIp(address)
 166                 .setRemotePort(port)
 167                 .build();
 168     }
 169
 170     public String connectionInfoToString(final ConnectionInfo connectionInfo) {
 171         return String.valueOf(
 172                 connectionInfo.getRemoteIp().getValue()) + ":" + connectionInfo.getRemotePort().getValue();
 173     }
 174
 175     public boolean addOvsdbNode(final ConnectionInfo connectionInfo) {
 176         boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
 177                 createInstanceIdentifier(connectionInfo),
 178                 createNode(connectionInfo));
 179         try {
 180             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 181         } catch (InterruptedException e) {
 182             LOG.warn("Interrupted while waiting after adding OVSDB node {}", connectionInfoToString(connectionInfo), e);
 183         }
 184         return result;
 185     }
 186
 187     public Node getOvsdbNode(final ConnectionInfo connectionInfo) {
 188         return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
 189                 createInstanceIdentifier(connectionInfo));
 190     }
 191
 192     public boolean deleteOvsdbNode(final ConnectionInfo connectionInfo) {
 193         boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 194                 createInstanceIdentifier(connectionInfo));
 195         try {
 196             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 197         } catch (InterruptedException e) {
 198             LOG.warn("Interrupted while waiting after deleting OVSDB node {}", connectionInfoToString(connectionInfo),
 199                     e);
 200         }
 201         return result;
 202     }
 203
 204     public Node connectOvsdbNode(final ConnectionInfo connectionInfo) {
 205         addOvsdbNode(connectionInfo);
 206         Node node = getOvsdbNode(connectionInfo);
 207         LOG.info("Connected to {}", connectionInfoToString(connectionInfo));
 208         return node;
 209     }
 210
 211     public boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) {
 212         deleteOvsdbNode(connectionInfo);
 213         LOG.info("Disconnected from {}", connectionInfoToString(connectionInfo));
 214         return true;
 215     }
 216
 217     public List<ControllerEntry> createControllerEntry(String controllerTarget) {
 218         List<ControllerEntry> controllerEntriesList = new ArrayList<>();
 219         controllerEntriesList.add(new ControllerEntryBuilder()
 220                 .setTarget(new Uri(controllerTarget))
 221                 .build());
 222         return controllerEntriesList;
 223     }
 224
 225     /**
 226      * Extract the <code>store</code> type data store contents for the particular bridge identified by
 227      * <code>bridgeName</code>.
 228      *
 229      * @param connectionInfo address for the node
 230      * @param bridgeName name of the bridge
 231      * @param store defined by the <code>LogicalDatastoreType</code> enumeration
 232      * @return <code>store</code> type data store contents
 233      */
 234     public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
 235                                               LogicalDatastoreType store) {
 236         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = null;
 237         Node bridgeNode = getBridgeNode(connectionInfo, bridgeName, store);
 238         if (bridgeNode != null) {
 239             ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 240         }
 241         return ovsdbBridgeAugmentation;
 242     }
 243
 244     /**
 245      * extract the <code>LogicalDataStoreType.OPERATIONAL</code> type data store contents for the particular bridge
 246      * identified by <code>bridgeName</code>
 247      *
 248      * @param connectionInfo address for the node
 249      * @param bridgeName name of the bridge
 250      * @see <code>NetvirtIT.getBridge(ConnectionInfo, String, LogicalDatastoreType)</code>
 251      * @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
 252      */
 253     public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
 254         return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
 255     }
 256
 257     /**
 258      * Extract the node contents from <code>store</code> type data store for the
 259      * bridge identified by <code>bridgeName</code>.
 260      *
 261      * @param connectionInfo address for the node
 262      * @param bridgeName name of the bridge
 263      * @param store defined by the <code>LogicalDatastoreType</code> enumeration
 264      * @return <code>store</code> type data store contents
 265      */
 266     public Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
 267         InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 268         return mdsalUtils.read(store, bridgeIid);
 269     }
 270
 271     public boolean deleteBridge(final ConnectionInfo connectionInfo, final String bridgeName) {
 272
 273         boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 274                 createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName)));
 275         try {
 276             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 277         } catch (InterruptedException e) {
 278             LOG.warn("Interrupted while waiting after deleting bridge {}", bridgeName, e);
 279         }
 280         return result;
 281     }
 282
 283     public List<ProtocolEntry> createMdsalProtocols() {
 284         List<ProtocolEntry> protocolList = new ArrayList<>();
 285         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 286                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 287         protocolList.add(new ProtocolEntryBuilder().setProtocol(mapper.get("OpenFlow13")).build());
 288         return protocolList;
 289     }
 290
 291     /*
 292      * base method for adding test bridges.  Other helper methods used to create bridges should utilize this method.
 293      *
 294      * @param connectionInfo
 295      * @param bridgeIid if passed null, one is created
 296      * @param bridgeName cannot be null
 297      * @param bridgeNodeId if passed null, one is created based on <code>bridgeIid</code>
 298      * @param setProtocolEntries toggles whether default protocol entries are set for the bridge
 299      * @param failMode toggles whether default fail mode is set for the bridge
 300      * @param setManagedBy toggles whether to setManagedBy for the bridge
 301      * @param dpType if passed null, this parameter is ignored
 302      * @param externalIds if passed null, this parameter is ignored
 303      * @param otherConfig if passed null, this parameter is ignored
 304      * @return success of bridge addition
 305      * @throws InterruptedException
 306      */
 307     public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
 308                              final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
 309                              final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
 310                              final Class<? extends DatapathTypeBase> dpType,
 311                              final List<BridgeExternalIds> externalIds,
 312                              final List<ControllerEntry> controllerEntries,
 313                              final List<BridgeOtherConfigs> otherConfigs,
 314                              final String dpid) throws InterruptedException {
 315
 316         NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 317         if (bridgeIid == null) {
 318             bridgeIid = createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 319         }
 320         if (bridgeNodeId == null) {
 321             bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
 322         }
 323         bridgeNodeBuilder.setNodeId(bridgeNodeId);
 324         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 325         ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 326         if (setProtocolEntries) {
 327             ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
 328         }
 329         if (failMode != null) {
 330             ovsdbBridgeAugmentationBuilder.setFailMode(failMode);
 331         }
 332         if (setManagedBy) {
 333             setManagedBy(ovsdbBridgeAugmentationBuilder, connectionInfo);
 334         }
 335         if (dpType != null) {
 336             ovsdbBridgeAugmentationBuilder.setDatapathType(dpType);
 337         }
 338         if (externalIds != null) {
 339             ovsdbBridgeAugmentationBuilder.setBridgeExternalIds(externalIds);
 340         }
 341         if (controllerEntries != null) {
 342             ovsdbBridgeAugmentationBuilder.setControllerEntry(controllerEntries);
 343         }
 344         if (otherConfigs != null) {
 345             ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(otherConfigs);
 346         }
 347         if (dpid != null && !dpid.isEmpty()) {
 348             DatapathId datapathId = new DatapathId(dpid);
 349             ovsdbBridgeAugmentationBuilder.setDatapathId(datapathId);
 350         }
 351         bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 352         LOG.debug("Built with the intent to store bridge data {}",
 353                 ovsdbBridgeAugmentationBuilder.toString());
 354         boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
 355                 bridgeIid, bridgeNodeBuilder.build());
 356         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 357         return result;
 358     }
 359
 360     public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
 361                              final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
 362                              final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
 363                              final Class<? extends DatapathTypeBase> dpType,
 364                              final List<BridgeExternalIds> externalIds,
 365                              final List<ControllerEntry> controllerEntries,
 366                              final List<BridgeOtherConfigs> otherConfigs) throws InterruptedException {
 367         return addBridge(connectionInfo, bridgeIid, bridgeName, bridgeNodeId, setProtocolEntries,
 368                 failMode, setManagedBy, dpType, externalIds, controllerEntries,
 369                 otherConfigs, null);
 370     }
 371
 372     public boolean addBridge(final ConnectionInfo connectionInfo, final String bridgeName)
 373             throws InterruptedException {
 374
 375         return addBridge(connectionInfo, null, bridgeName, null, true,
 376                 SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get("secure"), true, null, null, null, null);
 377     }
 378
 379     private void setManagedBy(final OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
 380                               final ConnectionInfo connectionInfo) {
 381         InstanceIdentifier<Node> connectionNodePath = createInstanceIdentifier(connectionInfo);
 382         ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
 383     }
 384
 385     public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
 386                                        String type, Map<String, String> options,
 387                                        Map<String, String> externalIds) {
 388         InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(bridgeNode, portName);
 389         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 390
 391         tpAugmentationBuilder.setName(portName);
 392         if (type != null) {
 393             tpAugmentationBuilder.setInterfaceType(OVSDB_INTERFACE_TYPE_MAP.get(type));
 394         }
 395
 396         if (options != null && options.size() > 0) {
 397             List<Options> optionsList = new ArrayList<>();
 398             for (Map.Entry<String, String> entry : options.entrySet()) {
 399                 OptionsBuilder optionsBuilder = new OptionsBuilder();
 400                 optionsBuilder.setKey(new OptionsKey(entry.getKey()));
 401                 optionsBuilder.setOption(entry.getKey());
 402                 optionsBuilder.setValue(entry.getValue());
 403                 optionsList.add(optionsBuilder.build());
 404             }
 405             tpAugmentationBuilder.setOptions(optionsList);
 406         }
 407
 408         if (externalIds != null && externalIds.size() > 0) {
 409             List<InterfaceExternalIds> externalIdsList = new ArrayList<>();
 410             for (Map.Entry<String, String> entry : externalIds.entrySet()) {
 411                 InterfaceExternalIdsBuilder interfaceExternalIdsBuilder = new InterfaceExternalIdsBuilder();
 412                 interfaceExternalIdsBuilder.setKey(new InterfaceExternalIdsKey(entry.getKey()));
 413                 interfaceExternalIdsBuilder.setExternalIdKey(entry.getKey());
 414                 interfaceExternalIdsBuilder.setExternalIdValue(entry.getValue());
 415                 externalIdsList.add(interfaceExternalIdsBuilder.build());
 416             }
 417             tpAugmentationBuilder.setInterfaceExternalIds(externalIdsList);
 418         }
 419
 420         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 421         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 422         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 423         /* TODO SB_MIGRATION should this be merge or mdsalUtils.put */
 424         return mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
 425     }
 426
 427     public TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName) {
 428         InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
 429                 bridgeNode, portName);
 430         return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, tpIid);
 431     }
 432
 433     public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type) {
 434         return addTerminationPoint(bridgeNode, bridgeName, portName, type, null, null);
 435     }
 436
 437     public Boolean addTunnelTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type,
 438                                              Map<String, String> options) {
 439         return addTerminationPoint(bridgeNode, bridgeName, portName, type, options, null);
 440     }
 441 }