openstack/net-virt/src/main/java/org/opendaylight/ovsdb/openstack/netvirt/MdsalUtils.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 package org.opendaylight.ovsdb.openstack.netvirt;
   9
  10 import java.math.BigInteger;
  11 import java.security.InvalidParameterException;
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  19 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  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.controller.md.sal.common.api.data.TransactionCommitFailedException;
  23 import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
  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.OvsdbBridgeAugmentation;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  49 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  50 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  51 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  52 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  56 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58 import org.slf4j.Logger;
  59 import org.slf4j.LoggerFactory;
  60
  61 import com.google.common.base.Optional;
  62 import com.google.common.collect.ImmutableBiMap;
  63 import com.google.common.util.concurrent.CheckedFuture;
  64
  65 /**
  66  * Utility class to wrap mdsal transactions.
  67  *
  68  * @author Sam Hague (shague@redhat.com)
  69  */
  70 public class MdsalUtils {
  71     private static final Logger LOG = LoggerFactory.getLogger(MdsalUtils.class);
  72
  73     public static DataBroker getDatabroker() {
  74         return databroker;
  75     }
  76
  77     private static DataBroker databroker = null;
  78     private static final int OVSDB_UPDATE_TIMEOUT = 500;
  79     private static final String PATCH_PORT_TYPE = "patch";
  80
  81     /**
  82      * Class constructor setting the data broker.
  83      *
  84      * @param dataBroker the {@link org.opendaylight.controller.md.sal.binding.api.DataBroker}
  85      */
  86     public MdsalUtils(DataBroker dataBroker) {
  87         this.databroker = dataBroker;
  88     }
  89
  90     /**
  91      * Executes delete as a blocking transaction.
  92      *
  93      * @param store {@link LogicalDatastoreType} which should be modified
  94      * @param path {@link InstanceIdentifier} to read from
  95      * @param <D> the data object type
  96      * @return the result of the request
  97      */
  98     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
  99             final LogicalDatastoreType store, final InstanceIdentifier<D> path)  {
 100         boolean result = false;
 101         final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
 102         transaction.delete(store, path);
 103         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 104         try {
 105             future.checkedGet();
 106             result = true;
 107         } catch (TransactionCommitFailedException e) {
 108             LOG.warn("Failed to delete {} ", path, e);
 109         }
 110         return result;
 111     }
 112
 113     /**
 114      * Executes merge as a blocking transaction.
 115      *
 116      * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
 117      * @param path {@link InstanceIdentifier} for path to read
 118      * @param <D> the data object type
 119      * @return the result of the request
 120      */
 121     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean merge(
 122             final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data)  {
 123         boolean result = false;
 124         final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
 125         transaction.merge(logicalDatastoreType, path, data, true);
 126         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 127         try {
 128             future.checkedGet();
 129             result = true;
 130         } catch (TransactionCommitFailedException e) {
 131             LOG.warn("Failed to merge {} ", path, e);
 132         }
 133         return result;
 134     }
 135
 136     /**
 137      * Executes put as a blocking transaction.
 138      *
 139      * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
 140      * @param path {@link InstanceIdentifier} for path to read
 141      * @param <D> the data object type
 142      * @return the result of the request
 143      */
 144     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean put(
 145             final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data)  {
 146         boolean result = false;
 147         final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
 148         transaction.put(logicalDatastoreType, path, data, true);
 149         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 150         try {
 151             future.checkedGet();
 152             result = true;
 153         } catch (TransactionCommitFailedException e) {
 154             LOG.warn("Failed to put {} ", path, e);
 155         }
 156         return result;
 157     }
 158
 159     /**
 160      * Executes read as a blocking transaction.
 161      *
 162      * @param store {@link LogicalDatastoreType} to read
 163      * @param path {@link InstanceIdentifier} for path to read
 164      * @param <D> the data object type
 165      * @return the result as the data object requested
 166      */
 167     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
 168             final LogicalDatastoreType store, final InstanceIdentifier<D> path)  {
 169         D result = null;
 170         final ReadOnlyTransaction transaction = databroker.newReadOnlyTransaction();
 171         Optional<D> optionalDataObject;
 172         CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
 173         try {
 174             optionalDataObject = future.checkedGet();
 175             if (optionalDataObject.isPresent()) {
 176                 result = optionalDataObject.get();
 177             } else {
 178                 LOG.debug("{}: Failed to read {}",
 179                         Thread.currentThread().getStackTrace()[1], path);
 180             }
 181         } catch (ReadFailedException e) {
 182             LOG.warn("Failed to read {} ", path, e);
 183         }
 184         transaction.close();
 185         return result;
 186     }
 187
 188     public static ConnectionInfo getConnectionInfo(Node node) {
 189         ConnectionInfo connectionInfo = null;
 190         OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 191         if (ovsdbNodeAugmentation != null) {
 192             connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
 193         }
 194         return connectionInfo;
 195     }
 196
 197     public static OvsdbNodeAugmentation extractOvsdbNode(Node node) {
 198         return node.getAugmentation(OvsdbNodeAugmentation.class);
 199     }
 200
 201     public static NodeId extractBridgeOvsdbNodeId(Node bridgeNode) {
 202         NodeId ovsdbNodeId = null;
 203         OvsdbBridgeAugmentation bridgeAugmentation = extractBridgeAugmentation(bridgeNode);
 204         if (bridgeAugmentation != null) {
 205             @SuppressWarnings("unchecked")
 206             InstanceIdentifier<Node> ovsdbNodeIid =
 207                     (InstanceIdentifier<Node>) (bridgeAugmentation.getManagedBy().getValue());
 208             ovsdbNodeId = InstanceIdentifier.keyOf(ovsdbNodeIid).getNodeId();
 209         }
 210         return ovsdbNodeId;
 211     }
 212
 213     public static List<Node> readOvsdbTopologyNodes() {
 214         List<Node> ovsdbNodes = new ArrayList<>();
 215         InstanceIdentifier<Topology> topologyInstanceIdentifier = MdsalHelper.createInstanceIdentifier();
 216         Topology topology = read(LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
 217         if (topology != null && topology.getNode() != null) {
 218             for (Node node : topology.getNode()) {
 219                 OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 220                 if (ovsdbNodeAugmentation != null) {
 221                     ovsdbNodes.add(node);
 222                 }
 223             }
 224         }
 225         return ovsdbNodes;
 226     }
 227
 228     public static OvsdbNodeAugmentation readOvsdbNode(Node bridgeNode) {
 229         OvsdbNodeAugmentation nodeAugmentation = null;
 230         OvsdbBridgeAugmentation bridgeAugmentation = extractBridgeAugmentation(bridgeNode);
 231         if(bridgeAugmentation != null){
 232             InstanceIdentifier<Node> ovsdbNodeIid =
 233                     (InstanceIdentifier<Node>) bridgeAugmentation.getManagedBy().getValue();
 234             Node node = read(LogicalDatastoreType.OPERATIONAL, ovsdbNodeIid);
 235             if (node != null){
 236                 nodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 237                 LOG.debug("readOvsdbNode: Ovsdb node {} found that manages bridge {}",
 238                         nodeAugmentation != null?nodeAugmentation:"not",bridgeAugmentation);
 239             }else {
 240                 LOG.debug ("readOvsdbNode: Ovsdb node that manages bridge {} not found. ",bridgeAugmentation);
 241             }
 242
 243         }else{
 244             LOG.debug("readOvsdbNode: Provided node is not a bridge node : {}",bridgeNode);
 245         }
 246         return nodeAugmentation;
 247     }
 248
 249     public static String getOvsdbNodeUUID(Node node) {
 250         String nodeUUID = null;
 251         OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 252         if (ovsdbNodeAugmentation != null) {
 253             // TODO replace with proper uuid and not the system-id
 254             nodeUUID = getOsdbNodeExternalIdsValue(ovsdbNodeAugmentation, "system-id");
 255         }
 256         return nodeUUID;
 257     }
 258
 259     public static String getOsdbNodeExternalIdsValue(OvsdbNodeAugmentation ovsdbNodeAugmentation, String key) {
 260         String value = null;
 261         List<OpenvswitchExternalIds> pairs = ovsdbNodeAugmentation.getOpenvswitchExternalIds();
 262         if (pairs != null && !pairs.isEmpty()) {
 263             for (OpenvswitchExternalIds pair : pairs) {
 264                 if (pair.getExternalIdKey().equals(key)) {
 265                     value = pair.getExternalIdValue();
 266                     break;
 267                 }
 268             }
 269         }
 270         return value;
 271     }
 272
 273     public static boolean addBridge(Node ovsdbNode, String bridgeName, String target)
 274             throws InterruptedException, InvalidParameterException {
 275         boolean result = false;
 276
 277         LOG.info("addBridge: node: {}, bridgeName: {}, target: {}", ovsdbNode, bridgeName, target);
 278         ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
 279         if (connectionInfo != null) {
 280             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 281             InstanceIdentifier<Node> bridgeIid =
 282                     MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
 283             NodeId bridgeNodeId = MdsalHelper.createManagedNodeId(bridgeIid);
 284             bridgeNodeBuilder.setNodeId(bridgeNodeId);
 285             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 286             ovsdbBridgeAugmentationBuilder.setControllerEntry(createControllerEntries(target));
 287             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 288             ovsdbBridgeAugmentationBuilder.setProtocolEntry(createMdsalProtocols());
 289             ovsdbBridgeAugmentationBuilder.setFailMode(
 290                     MdsalHelper.OVSDB_FAIL_MODE_MAP.inverse().get("secure"));
 291             setManagedByForBridge(ovsdbBridgeAugmentationBuilder, connectionInfo);
 292             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 293
 294             result = put(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
 295             LOG.info("addBridge: result: {}", result);
 296         } else {
 297             throw new InvalidParameterException("Could not find ConnectionInfo");
 298         }
 299         return result;
 300     }
 301
 302     public static boolean deleteBridge(Node ovsdbNode) {
 303         boolean result = false;
 304         InstanceIdentifier<Node> bridgeIid =
 305                 MdsalHelper.createInstanceIdentifier(ovsdbNode.getNodeId());
 306
 307         result = delete(LogicalDatastoreType.CONFIGURATION, bridgeIid);
 308         LOG.info("deleteBridge node: {}, bridgeName: {} result : {}", ovsdbNode, ovsdbNode.getNodeId(),result);
 309         return result;
 310     }
 311
 312     public static OvsdbBridgeAugmentation readBridge(Node node, String name) {
 313         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = null;
 314         ConnectionInfo connectionInfo = getConnectionInfo(node);
 315         if (connectionInfo != null) {
 316             InstanceIdentifier<Node> bridgeIid =
 317                     MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(name));
 318             Node bridgeNode = read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
 319             if (bridgeNode != null) {
 320                 ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 321             }
 322         }
 323         return ovsdbBridgeAugmentation;
 324     }
 325
 326     public static Node readBridgeNode(Node node, String name) {
 327         Node bridgeNode = null;
 328         ConnectionInfo connectionInfo = getConnectionInfo(node);
 329         if (connectionInfo != null) {
 330             InstanceIdentifier<Node> bridgeIid =
 331                     MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(name));
 332             bridgeNode = read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
 333         }
 334         return bridgeNode;
 335     }
 336
 337     public static Node getBridgeNode(Node node, String bridgeName) {
 338         Node bridgeNode = null;
 339         OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
 340         if (bridge != null) {
 341             if (bridge.getBridgeName().getValue().equals(bridgeName)) {
 342                 bridgeNode = node;
 343             }
 344         } else {
 345             bridgeNode = readBridgeNode(node, bridgeName);
 346         }
 347
 348         return bridgeNode;
 349     }
 350
 351     public static String getBridgeUuid(Node node, String name) {
 352         String uuid = null;
 353         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = readBridge(node, name);
 354         if (ovsdbBridgeAugmentation != null) {
 355             uuid = ovsdbBridgeAugmentation.getBridgeUuid().getValue();
 356         }
 357         return uuid;
 358     }
 359
 360     private static void setManagedByForBridge(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
 361                                      ConnectionInfo connectionInfo) {
 362         InstanceIdentifier<Node> connectionNodePath = MdsalHelper.createInstanceIdentifier(connectionInfo);
 363         ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath));
 364     }
 365
 366     private static void setControllerForBridge(Node ovsdbNode, String bridgeName, String targetString) {
 367         ConnectionInfo connectionInfo = getConnectionInfo(ovsdbNode);
 368         if (connectionInfo != null) {
 369             for (ControllerEntry controllerEntry: createControllerEntries(targetString)) {
 370                 InstanceIdentifier<ControllerEntry> iid =
 371                         MdsalHelper.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName))
 372                                 .augmentation(OvsdbBridgeAugmentation.class)
 373                                 .child(ControllerEntry.class, controllerEntry.getKey());
 374
 375                 boolean result = put(LogicalDatastoreType.CONFIGURATION, iid, controllerEntry);
 376                 LOG.info("addController: result: {}", result);
 377             }
 378         }
 379     }
 380
 381     private static List<ControllerEntry> createControllerEntries(String targetString) {
 382         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 383         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 384         controllerEntryBuilder.setTarget(new Uri(targetString));
 385         controllerEntries.add(controllerEntryBuilder.build());
 386         return controllerEntries;
 387     }
 388
 389     private static List<ProtocolEntry> createMdsalProtocols() {
 390         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 391         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 392                 MdsalHelper.OVSDB_PROTOCOL_MAP.inverse();
 393         protocolList.add(new ProtocolEntryBuilder().
 394                 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
 395         return protocolList;
 396     }
 397
 398     public static long getDataPathId(Node node) {
 399         long dpid = 0L;
 400         String datapathId = getDatapathId(node);
 401         if (datapathId != null) {
 402             dpid = new BigInteger(datapathId.replaceAll(":", ""), 16).longValue();
 403         }
 404         return dpid;
 405     }
 406
 407     public static String getDatapathId(Node node) {
 408         String datapathId = null;
 409         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
 410         if (ovsdbBridgeAugmentation != null && ovsdbBridgeAugmentation.getDatapathId() != null) {
 411             datapathId = node.getAugmentation(OvsdbBridgeAugmentation.class).getDatapathId().getValue();
 412         }
 413         return datapathId;
 414     }
 415
 416     public static String getDatapathId(OvsdbBridgeAugmentation ovsdbBridgeAugmentation) {
 417         String datapathId = null;
 418         if (ovsdbBridgeAugmentation != null && ovsdbBridgeAugmentation.getDatapathId() != null) {
 419             datapathId = ovsdbBridgeAugmentation.getDatapathId().getValue();
 420         }
 421         return datapathId;
 422     }
 423
 424     public static OvsdbBridgeAugmentation getBridge(Node node, String name) {
 425         OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
 426         if (bridge != null) {
 427             if (!bridge.getBridgeName().getValue().equals(name)) {
 428                 bridge = null;
 429             }
 430         }
 431         return bridge;
 432     }
 433
 434     public static OvsdbBridgeAugmentation getBridge(Node node) {
 435         OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
 436         return bridge;
 437     }
 438
 439     public static String getBridgeName(Node node) {
 440         String bridgeName = null;
 441         OvsdbBridgeAugmentation bridge = getBridge(node);
 442         if (bridge != null) {
 443             bridgeName = bridge.getBridgeName().getValue();
 444         }
 445         return bridgeName;
 446     }
 447
 448     public static String extractBridgeName(Node node) {
 449         return (node.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue());
 450     }
 451
 452     public static OvsdbBridgeAugmentation extractBridgeAugmentation(Node node) {
 453         return node.getAugmentation(OvsdbBridgeAugmentation.class);
 454     }
 455
 456     public static List<Node> getAllBridgesOnOvsdbNode(Node node) {
 457         List<Node> nodes = new ArrayList<Node>();
 458         List<ManagedNodeEntry> managedNodes = node.getAugmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
 459         for (ManagedNodeEntry managedNode : managedNodes) {
 460             InstanceIdentifier<?> bridgeIid = managedNode.getBridgeRef().getValue();
 461             Node bridgeNode = (Node) read(LogicalDatastoreType.OPERATIONAL, bridgeIid);
 462             if (bridgeNode != null) {
 463                 nodes.add(bridgeNode);
 464             }
 465         }
 466         return nodes;
 467     }
 468
 469     public static OvsdbNodeAugmentation extractNodeAugmentation(Node node) {
 470         return node.getAugmentation(OvsdbNodeAugmentation.class);
 471     }
 472
 473     /**
 474      * Method read ports from bridge node. Method will check if the provided node
 475      * has the ports details, if not, it will read from Operational data store.
 476      * @param node
 477      * @return
 478      */
 479     public static List<OvsdbTerminationPointAugmentation> getTerminationPointsOfBridge(Node node) {
 480         List<OvsdbTerminationPointAugmentation> tpAugmentations = extractTerminationPointAugmentations(node);
 481         if(tpAugmentations.isEmpty()){
 482             tpAugmentations = readTerminationPointAugmentations(node);
 483         }
 484         return tpAugmentations;
 485     }
 486
 487     public static OvsdbTerminationPointAugmentation extractTerminationPointAugmentation(Node bridgeNode, String portName) {
 488         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.getAugmentation(OvsdbBridgeAugmentation.class);
 489         if (ovsdbBridgeAugmentation != null) {
 490             List<TerminationPoint> terminationPoints = bridgeNode.getTerminationPoint();
 491             for(TerminationPoint terminationPoint : terminationPoints) {
 492                 OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
 493                         terminationPoint.getAugmentation( OvsdbTerminationPointAugmentation.class);
 494                 if (ovsdbTerminationPointAugmentation != null
 495                         && ovsdbTerminationPointAugmentation.getName().equals(portName)) {
 496                     return ovsdbTerminationPointAugmentation;
 497                 }
 498             }
 499         }
 500         return null;
 501     }
 502
 503     public static List<TerminationPoint> extractTerminationPoints(Node node) {
 504         List<TerminationPoint> terminationPoints = new ArrayList<TerminationPoint>();
 505         OvsdbBridgeAugmentation ovsdbBridgeAugmentation = node.getAugmentation(OvsdbBridgeAugmentation.class);
 506         if (ovsdbBridgeAugmentation != null) {
 507             terminationPoints.addAll(node.getTerminationPoint());
 508         }
 509         return terminationPoints;
 510     }
 511
 512     public static List<OvsdbTerminationPointAugmentation> extractTerminationPointAugmentations( Node node ) {
 513         List<OvsdbTerminationPointAugmentation> tpAugmentations = new ArrayList<OvsdbTerminationPointAugmentation>();
 514         List<TerminationPoint> terminationPoints = node.getTerminationPoint();
 515         if(terminationPoints != null && !terminationPoints.isEmpty()){
 516             for(TerminationPoint tp : terminationPoints){
 517                 tpAugmentations.add(tp.getAugmentation(OvsdbTerminationPointAugmentation.class));
 518             }
 519         }
 520         return tpAugmentations;
 521     }
 522
 523     public static List<OvsdbTerminationPointAugmentation> readTerminationPointAugmentations(Node node) {
 524         InstanceIdentifier<Node> bridgeNodeIid = MdsalHelper.createInstanceIdentifier(node.getNodeId());
 525         Node operNode = read(LogicalDatastoreType.OPERATIONAL, bridgeNodeIid);
 526         if(operNode != null){
 527             return extractTerminationPointAugmentations(operNode);
 528         }
 529         return new ArrayList<OvsdbTerminationPointAugmentation>();
 530     }
 531
 532     public static String getInterfaceExternalIdsValue(
 533             OvsdbTerminationPointAugmentation terminationPointAugmentation, String key) {
 534         String value = null;
 535         List<InterfaceExternalIds> pairs = terminationPointAugmentation.getInterfaceExternalIds();
 536         if (pairs != null && !pairs.isEmpty()) {
 537             for (InterfaceExternalIds pair : pairs) {
 538                 if (pair.getExternalIdKey().equals(key)) {
 539                     value = pair.getExternalIdValue();
 540                     break;
 541                 }
 542             }
 543         }
 544         return value;
 545     }
 546
 547     public static Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type) {
 548         InstanceIdentifier<TerminationPoint> tpIid =
 549                 MdsalHelper.createTerminationPointInstanceIdentifier(bridgeNode, portName);
 550         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 551                 new OvsdbTerminationPointAugmentationBuilder();
 552
 553         tpAugmentationBuilder.setName(portName);
 554         if (type != null) {
 555             tpAugmentationBuilder.setInterfaceType(MdsalHelper.OVSDB_INTERFACE_TYPE_MAP.get(type));
 556         }
 557         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 558         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 559         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 560         return put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
 561     }
 562
 563     public static Boolean deleteTerminationPoint(Node bridgeNode, String portName) {
 564         InstanceIdentifier<TerminationPoint> tpIid =
 565                 MdsalHelper.createTerminationPointInstanceIdentifier(bridgeNode, portName);
 566         return delete(LogicalDatastoreType.CONFIGURATION, tpIid);
 567     }
 568
 569     public static Boolean addTerminationPoint(Node bridgeNode, String bridgeName, String portName,
 570             String type, Map<String, String> options) {
 571         InstanceIdentifier<TerminationPoint> tpIid = MdsalHelper.createTerminationPointInstanceIdentifier(
 572                 bridgeNode, portName);
 573         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 574
 575         tpAugmentationBuilder.setName(portName);
 576         if (type != null) {
 577             tpAugmentationBuilder.setInterfaceType(MdsalHelper.OVSDB_INTERFACE_TYPE_MAP.get(type));
 578         }
 579
 580         List<Options> optionsList = new ArrayList<Options>();
 581         for (Map.Entry<String, String> entry : options.entrySet()) {
 582             OptionsBuilder optionsBuilder = new OptionsBuilder();
 583             optionsBuilder.setKey(new OptionsKey(entry.getKey()));
 584             optionsBuilder.setOption(entry.getKey());
 585             optionsBuilder.setValue(entry.getValue());
 586             optionsList.add(optionsBuilder.build());
 587         }
 588         tpAugmentationBuilder.setOptions(optionsList);
 589
 590         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 591         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 592         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 593         /* TODO SB_MIGRATION should this be merge or put */
 594         return put(LogicalDatastoreType.CONFIGURATION, tpIid, tpBuilder.build());
 595     }
 596
 597     public static TerminationPoint readTerminationPoint(Node bridgeNode, String bridgeName, String portName) {
 598         InstanceIdentifier<TerminationPoint> tpIid = MdsalHelper.createTerminationPointInstanceIdentifier(
 599                 bridgeNode, portName);
 600         return read(LogicalDatastoreType.OPERATIONAL, tpIid);
 601     }
 602
 603     public static Boolean addTunnelTerminationPoint(Node bridgeNode, String bridgeName, String portName, String type,
 604                                         Map<String, String> options) {
 605         return addTerminationPoint(bridgeNode, bridgeName, portName, type, options);
 606     }
 607
 608     public static Boolean isTunnelTerminationPointExist(Node bridgeNode, String bridgeName, String portName){
 609         return readTerminationPoint(bridgeNode, bridgeName, portName) != null;
 610     }
 611
 612     public static Boolean addPatchTerminationPoint(Node node, String bridgeName, String portName, String peerPortName) {
 613         Map<String, String> option = new HashMap<String, String>();
 614         option.put("peer", peerPortName);
 615         return addTerminationPoint(node, bridgeName, portName, PATCH_PORT_TYPE, option);
 616     }
 617
 618     public static String getExternalId(Node node, OvsdbTables table, String key) {
 619         switch (table) {
 620         case BRIDGE:
 621             OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
 622             if (bridge != null && bridge.getBridgeExternalIds() != null) {
 623                 for (BridgeExternalIds bridgeExternaIds :bridge.getBridgeExternalIds()) {
 624                     if (bridgeExternaIds.getBridgeExternalIdKey().equals(key)) {
 625                         return bridgeExternaIds.getBridgeExternalIdValue();
 626                     }
 627                 }
 628             }
 629             break;
 630         case CONTROLLER:
 631             LOG.warn("getExternalId: There is no external_id for OvsdbTables: ", table);
 632             return null;
 633         case OPENVSWITCH:
 634             OvsdbNodeAugmentation ovsdbNode = extractNodeAugmentation(node);
 635             if (ovsdbNode != null && ovsdbNode.getOpenvswitchExternalIds() != null) {
 636                 for (OpenvswitchExternalIds openvswitchExternalIds : ovsdbNode.getOpenvswitchExternalIds()) {
 637                     if (openvswitchExternalIds.getExternalIdKey().equals(key)) {
 638                         return openvswitchExternalIds.getExternalIdValue();
 639                     }
 640                 }
 641             }
 642             break;
 643         case PORT:
 644             List <OvsdbTerminationPointAugmentation> ports = extractTerminationPointAugmentations(node);
 645             for (OvsdbTerminationPointAugmentation port : ports) {
 646                 if (port != null && port.getPortExternalIds() != null) {
 647                     for (PortExternalIds portExternalIds :port.getPortExternalIds()) {
 648                         if (portExternalIds.getExternalIdKey().equals(key)) {
 649                             return portExternalIds.getExternalIdValue();
 650                         }
 651                     }
 652                 }
 653             }
 654             break;
 655         default:
 656             LOG.debug("getExternalId: Couldn't find the specified OvsdbTable: ", table);
 657             return null;
 658         }
 659         return null;
 660     }
 661
 662     public static String getOtherConfig(Node node, OvsdbTables table, String key) {
 663         switch (table) {
 664             case BRIDGE:
 665                 OvsdbBridgeAugmentation bridge = extractBridgeAugmentation(node);
 666                 if (bridge != null && bridge.getBridgeOtherConfigs() != null) {
 667                     for (BridgeOtherConfigs bridgeOtherConfigs : bridge.getBridgeOtherConfigs()) {
 668                         if (bridgeOtherConfigs.getBridgeOtherConfigKey().equals(key)) {
 669                             return bridgeOtherConfigs.getBridgeOtherConfigValue();
 670                         }
 671                     }
 672                 }
 673                 break;
 674             case CONTROLLER:
 675                 LOG.warn("getOtherConfig: There is no other_config for OvsdbTables: ", table);
 676                 return null;
 677
 678             case OPENVSWITCH:
 679                 OvsdbNodeAugmentation ovsdbNode = extractNodeAugmentation(node);
 680                 if (ovsdbNode == null){
 681                     ovsdbNode = readOvsdbNode(node);
 682                 }
 683                 if (ovsdbNode != null && ovsdbNode.getOpenvswitchOtherConfigs() != null) {
 684                     for (OpenvswitchOtherConfigs openvswitchOtherConfigs : ovsdbNode.getOpenvswitchOtherConfigs()) {
 685                         if (openvswitchOtherConfigs.getOtherConfigKey().equals(key)) {
 686                             return openvswitchOtherConfigs.getOtherConfigValue();
 687                         }
 688                     }
 689                 }
 690                 break;
 691             case PORT:
 692                 List <OvsdbTerminationPointAugmentation> ports = extractTerminationPointAugmentations(node);
 693                 for (OvsdbTerminationPointAugmentation port : ports) {
 694                     if (port != null && port.getPortOtherConfigs() != null) {
 695                         for (PortOtherConfigs portOtherConfigs : port.getPortOtherConfigs()) {
 696                             if (portOtherConfigs.getOtherConfigKey().equals(key)) {
 697                                 return portOtherConfigs.getOtherConfigValue();
 698                             }
 699                         }
 700                     }
 701                 }
 702                 break;
 703             default:
 704                 LOG.debug("getOtherConfig: Couldn't find the specified OvsdbTable: ", table);
 705                 return null;
 706         }
 707         return null;
 708     }
 709
 710     public static boolean addVlanToTp(long vlan) {
 711         return false;
 712     }
 713
 714     public static boolean isTunnel(OvsdbTerminationPointAugmentation port) {
 715         LOG.trace("MdsalUtils#isTunnel: Interface : {}", port);
 716
 717         if(port.getInterfaceType() == null){
 718             LOG.warn("No type found for the interface : {}", port);
 719             return false;
 720         }
 721         return MdsalHelper.createOvsdbInterfaceType(
 722                 port.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_VXLAN)
 723                 || MdsalHelper.createOvsdbInterfaceType(
 724                 port.getInterfaceType()).equals(NetworkHandler.NETWORK_TYPE_GRE);
 725     }
 726
 727     public static String getOptionsValue(List<Options> options, String key) {
 728         String value = null;
 729         for (Options option : options) {
 730             if (option.getKey().equals(key)) {
 731                 value = option.getValue();
 732             }
 733         }
 734         return value;
 735     }
 736
 737     private static Topology getOvsdbTopology() {
 738         InstanceIdentifier<Topology> path = InstanceIdentifier
 739                 .create(NetworkTopology.class)
 740                 .child(Topology.class, new TopologyKey(MdsalHelper.OVSDB_TOPOLOGY_ID));
 741
 742         Topology topology = read(LogicalDatastoreType.OPERATIONAL, path);
 743         return topology;
 744     }
 745
 746     public static Long getOFPort(OvsdbTerminationPointAugmentation port) {
 747         Long ofPort = 0L;
 748         if (port.getOfport() != null) {
 749             ofPort = port.getOfport();
 750         }
 751         return ofPort;
 752     }
 753
 754     public static Long getOFPort(Node bridgeNode, String portName) {
 755         Long ofPort = 0L;
 756         OvsdbTerminationPointAugmentation port = extractTerminationPointAugmentation(bridgeNode, portName);
 757         if (port != null) {
 758             ofPort = getOFPort(port);
 759         } else {
 760             TerminationPoint tp = readTerminationPoint(bridgeNode, null, portName);
 761             if (tp != null) {
 762                 port = tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
 763                 if (port != null) {
 764                     ofPort = getOFPort(port);
 765                 }
 766             }
 767         }
 768         return ofPort;
 769     }
 770 }