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                 + new String(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 new String(connectionInfo.getRemoteIp().getValue()) + ":" + connectionInfo.getRemotePort().getValue();
 172     }
 173
 174     public boolean addOvsdbNode(final ConnectionInfo connectionInfo) {
 175         boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
 176                 createInstanceIdentifier(connectionInfo),
 177                 createNode(connectionInfo));
 178         try {
 179             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 180         } catch (InterruptedException e) {
 181             LOG.warn("Interrupted while waiting after adding OVSDB node {}", connectionInfoToString(connectionInfo), e);
 182         }
 183         return result;
 184     }
 185
 186     public Node getOvsdbNode(final ConnectionInfo connectionInfo) {
 187         return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
 188                 createInstanceIdentifier(connectionInfo));
 189     }
 190
 191     public boolean deleteOvsdbNode(final ConnectionInfo connectionInfo) {
 192         boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 193                 createInstanceIdentifier(connectionInfo));
 194         try {
 195             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 196         } catch (InterruptedException e) {
 197             LOG.warn("Interrupted while waiting after deleting OVSDB node {}", connectionInfoToString(connectionInfo),
 198                     e);
 199         }
 200         return result;
 201     }
 202
 203     public Node connectOvsdbNode(final ConnectionInfo connectionInfo) {
 204         addOvsdbNode(connectionInfo);
 205         Node node = getOvsdbNode(connectionInfo);
 206         LOG.info("Connected to {}", connectionInfoToString(connectionInfo));
 207         return node;
 208     }
 209
 210     public boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) {
 211         deleteOvsdbNode(connectionInfo);
 212         LOG.info("Disconnected from {}", connectionInfoToString(connectionInfo));
 213         return true;
 214     }
 215
 216     public List<ControllerEntry> createControllerEntry(String controllerTarget) {
 217         List<ControllerEntry> controllerEntriesList = new ArrayList<>();
 218         controllerEntriesList.add(new ControllerEntryBuilder()
 219                 .setTarget(new Uri(controllerTarget))
 220                 .build());
 221         return controllerEntriesList;
 222     }
 223
 224     /**
 225      * Extract the <code>store</code> type data store contents for the particular bridge identified by
 226      * <code>bridgeName</code>.
 227      *
 228      * @param connectionInfo address for the node
 229      * @param bridgeName name of the bridge
 230      * @param store defined by the <code>LogicalDatastoreType</code> enumeration
 231      * @return <code>store</code> type data store contents
 232      */
 233     public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
 234                                               LogicalDatastoreType store) {
 235         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = null;
 236         Node bridgeNode = getBridgeNode(connectionInfo, bridgeName, store);
 237         if (bridgeNode != null) {
 238             ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 239         }
 240         return ovsdbBridgeAugmentation;
 241     }
 242
 243     /**
 244      * extract the <code>LogicalDataStoreType.OPERATIONAL</code> type data store contents for the particular bridge
 245      * identified by <code>bridgeName</code>
 246      *
 247      * @param connectionInfo address for the node
 248      * @param bridgeName name of the bridge
 249      * @see <code>NetvirtIT.getBridge(ConnectionInfo, String, LogicalDatastoreType)</code>
 250      * @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
 251      */
 252     public OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
 253         return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
 254     }
 255
 256     /**
 257      * Extract the node contents from <code>store</code> type data store for the
 258      * bridge identified by <code>bridgeName</code>.
 259      *
 260      * @param connectionInfo address for the node
 261      * @param bridgeName name of the bridge
 262      * @param store defined by the <code>LogicalDatastoreType</code> enumeration
 263      * @return <code>store</code> type data store contents
 264      */
 265     public Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
 266         InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 267         return mdsalUtils.read(store, bridgeIid);
 268     }
 269
 270     public boolean deleteBridge(final ConnectionInfo connectionInfo, final String bridgeName) {
 271
 272         boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 273                 createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName)));
 274         try {
 275             Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 276         } catch (InterruptedException e) {
 277             LOG.warn("Interrupted while waiting after deleting bridge {}", bridgeName, e);
 278         }
 279         return result;
 280     }
 281
 282     public List<ProtocolEntry> createMdsalProtocols() {
 283         List<ProtocolEntry> protocolList = new ArrayList<>();
 284         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 285                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 286         protocolList.add(new ProtocolEntryBuilder().setProtocol(mapper.get("OpenFlow13")).build());
 287         return protocolList;
 288     }
 289
 290     /*
 291      * base method for adding test bridges.  Other helper methods used to create bridges should utilize this method.
 292      *
 293      * @param connectionInfo
 294      * @param bridgeIid if passed null, one is created
 295      * @param bridgeName cannot be null
 296      * @param bridgeNodeId if passed null, one is created based on <code>bridgeIid</code>
 297      * @param setProtocolEntries toggles whether default protocol entries are set for the bridge
 298      * @param failMode toggles whether default fail mode is set for the bridge
 299      * @param setManagedBy toggles whether to setManagedBy for the bridge
 300      * @param dpType if passed null, this parameter is ignored
 301      * @param externalIds if passed null, this parameter is ignored
 302      * @param otherConfig if passed null, this parameter is ignored
 303      * @return success of bridge addition
 304      * @throws InterruptedException
 305      */
 306     public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
 307                              final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
 308                              final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
 309                              final Class<? extends DatapathTypeBase> dpType,
 310                              final List<BridgeExternalIds> externalIds,
 311                              final List<ControllerEntry> controllerEntries,
 312                              final List<BridgeOtherConfigs> otherConfigs,
 313                              final String dpid) throws InterruptedException {
 314
 315         NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 316         if (bridgeIid == null) {
 317             bridgeIid = createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 318         }
 319         if (bridgeNodeId == null) {
 320             bridgeNodeId = SouthboundMapper.createManagedNodeId(bridgeIid);
 321         }
 322         bridgeNodeBuilder.setNodeId(bridgeNodeId);
 323         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 324         ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 325         if (setProtocolEntries) {
 326             ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
 327         }
 328         if (failMode != null) {
 329             ovsdbBridgeAugmentationBuilder.setFailMode(failMode);
 330         }
 331         if (setManagedBy) {
 332             setManagedBy(ovsdbBridgeAugmentationBuilder, connectionInfo);
 333         }
 334         if (dpType != null) {
 335             ovsdbBridgeAugmentationBuilder.setDatapathType(dpType);
 336         }
 337         if (externalIds != null) {
 338             ovsdbBridgeAugmentationBuilder.setBridgeExternalIds(externalIds);
 339         }
 340         if (controllerEntries != null) {
 341             ovsdbBridgeAugmentationBuilder.setControllerEntry(controllerEntries);
 342         }
 343         if (otherConfigs != null) {
 344             ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(otherConfigs);
 345         }
 346         if (dpid != null && !dpid.isEmpty()) {
 347             DatapathId datapathId = new DatapathId(dpid);
 348             ovsdbBridgeAugmentationBuilder.setDatapathId(datapathId);
 349         }
 350         bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 351         LOG.debug("Built with the intent to store bridge data {}",
 352                 ovsdbBridgeAugmentationBuilder.toString());
 353         boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION,
 354                 bridgeIid, bridgeNodeBuilder.build());
 355         Thread.sleep(OVSDB_UPDATE_TIMEOUT);
 356         return result;
 357     }
 358
 359     public boolean addBridge(final ConnectionInfo connectionInfo, InstanceIdentifier<Node> bridgeIid,
 360                              final String bridgeName, NodeId bridgeNodeId, final boolean setProtocolEntries,
 361                              final Class<? extends OvsdbFailModeBase> failMode, final boolean setManagedBy,
 362                              final Class<? extends DatapathTypeBase> dpType,
 363                              final List<BridgeExternalIds> externalIds,
 364                              final List<ControllerEntry> controllerEntries,
 365                              final List<BridgeOtherConfigs> otherConfigs) throws InterruptedException {
 366         return addBridge(connectionInfo, bridgeIid, bridgeName, bridgeNodeId, setProtocolEntries,
 367                 failMode, setManagedBy, dpType, externalIds, controllerEntries,
 368                 otherConfigs, null);
 369     }
 370
 371     public boolean addBridge(final ConnectionInfo connectionInfo, final String bridgeName)
 372             throws InterruptedException {
 373
 374         return addBridge(connectionInfo, null, bridgeName, null, true,
 375                 SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get("secure"), true, null, null, null, null);
 376     }
 377
 378     private void setManagedBy(final OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
 379                               final ConnectionInfo connectionInfo) {
 380         InstanceIdentifier<Node> connectionNodePath = createInstanceIdentifier(connectionInfo);
 381         ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
 382     }
 383
 384     public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
 385                                        String type, Map<String, String> options,
 386                                        Map<String, String> externalIds) {
 387         InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(bridgeNode, portName);
 388         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 389
 390         tpAugmentationBuilder.setName(portName);
 391         if (type != null) {
 392             tpAugmentationBuilder.setInterfaceType(OVSDB_INTERFACE_TYPE_MAP.get(type));
 393         }
 394
 395         if (options != null && options.size() > 0) {
 396             List<Options> optionsList = new ArrayList<>();
 397             for (Map.Entry<String, String> entry : options.entrySet()) {
 398                 OptionsBuilder optionsBuilder = new OptionsBuilder();
 399                 optionsBuilder.setKey(new OptionsKey(entry.getKey()));
 400                 optionsBuilder.setOption(entry.getKey());
 401                 optionsBuilder.setValue(entry.getValue());
 402                 optionsList.add(optionsBuilder.build());
 403             }
 404             tpAugmentationBuilder.setOptions(optionsList);
 405         }
 406
 407         if (externalIds != null && externalIds.size() > 0) {
 408             List<InterfaceExternalIds> externalIdsList = new ArrayList<>();
 409             for (Map.Entry<String, String> entry : externalIds.entrySet()) {
 410                 InterfaceExternalIdsBuilder interfaceExternalIdsBuilder = new InterfaceExternalIdsBuilder();
 411                 interfaceExternalIdsBuilder.setKey(new InterfaceExternalIdsKey(entry.getKey()));
 412                 interfaceExternalIdsBuilder.setExternalIdKey(entry.getKey());
 413                 interfaceExternalIdsBuilder.setExternalIdValue(entry.getValue());
 414                 externalIdsList.add(interfaceExternalIdsBuilder.build());
 415             }
 416             tpAugmentationBuilder.setInterfaceExternalIds(externalIdsList);
 417         }
 418
 419         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 420         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 421         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 422         /* TODO SB_MIGRATION should this be merge or mdsalUtils.put */
 423         return mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
 424     }
 425
 426     public TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName) {
 427         InstanceIdentifier<TerminationPoint> tpIid = createTerminationPointInstanceIdentifier(
 428                 bridgeNode, portName);
 429         return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL, tpIid);
 430     }
 431
 432     public Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type) {
 433         return addTerminationPoint(bridgeNode, bridgeName, portName, type, null, null);
 434     }
 435
 436     public Boolean addTunnelTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type,
 437                                              Map<String, String> options) {
 438         return addTerminationPoint(bridgeNode, bridgeName, portName, type, options, null);
 439     }
 440 }