impl/src/main/java/org/opendaylight/unimgr/impl/UnimgrUtils.java

   1 /*
   2  * Copyright (c) 2015 CableLabs 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.unimgr.impl;
   9
  10 import java.net.InetAddress;
  11 import java.net.UnknownHostException;
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18 import java.util.Set;
  19 import java.util.UUID;
  20 import java.util.concurrent.ExecutionException;
  21
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
  25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  26 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  27 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  28 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  29 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.EvcAugmentation;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.Uni;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentation;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentationBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  60 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  67 import org.opendaylight.yangtools.yang.binding.DataObject;
  68 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  69 import org.slf4j.Logger;
  70 import org.slf4j.LoggerFactory;
  71
  72 import com.google.common.base.Optional;
  73 import com.google.common.collect.ImmutableBiMap;
  74 import com.google.common.collect.Lists;
  75 import com.google.common.util.concurrent.CheckedFuture;
  76
  77 public class UnimgrUtils {
  78
  79     private static final Logger LOG = LoggerFactory.getLogger(UnimgrUtils.class);
  80
  81     public static final Optional<Node> readNode(DataBroker dataBroker,
  82             InstanceIdentifier<?> genericNode) {
  83         ReadTransaction read = dataBroker.newReadOnlyTransaction();
  84         InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
  85         CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = read
  86                 .read(LogicalDatastoreType.OPERATIONAL, nodeIid);
  87         Optional<Node> nodeOptional;
  88         try {
  89             nodeOptional = nodeFuture.get();
  90             return nodeOptional;
  91         } catch (InterruptedException e) {
  92             return Optional.absent();
  93         } catch (ExecutionException e) {
  94             return Optional.absent();
  95         }
  96     }
  97
  98     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
  99             DataBroker dataBroker,
 100             final LogicalDatastoreType store,
 101             final InstanceIdentifier<D> path)  {
 102         D result = null;
 103         final ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
 104         Optional<D> optionalDataObject;
 105         CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
 106         try {
 107             optionalDataObject = future.checkedGet();
 108             if (optionalDataObject.isPresent()) {
 109                 result = optionalDataObject.get();
 110             } else {
 111                 LOG.debug("{}: Failed to read {}",
 112                         Thread.currentThread().getStackTrace()[1], path);
 113             }
 114         } catch (ReadFailedException e) {
 115             LOG.warn("Failed to read {} ", path, e);
 116         }
 117         transaction.close();
 118         return result;
 119     }
 120
 121     public static OvsdbBridgeAugmentation createOvsdbBridgeAugmentation(Uni uni) throws Exception {
 122         OvsdbNodeRef ovsdbNodeRef = uni.getOvsdbNodeRef();
 123         if (ovsdbNodeRef != null && ovsdbNodeRef.getValue() != null) {
 124             UUID bridgeUuid = UUID.randomUUID();
 125             OvsdbBridgeAugmentation ovsdbBridge = new OvsdbBridgeAugmentationBuilder()
 126                         .setBridgeName(new OvsdbBridgeName(UnimgrConstants.DEFAULT_BRIDGE_NAME))
 127                         .setManagedBy(ovsdbNodeRef)
 128                         .setBridgeUuid(new Uuid(bridgeUuid.toString()))
 129                         .build();
 130             return ovsdbBridge;
 131         } else {
 132             throw new Exception("Ovsdb Node Reference does not exist !");
 133         }
 134     }
 135
 136     public static OvsdbNodeAugmentation createOvsdbNodeAugmentation(Uni uni) {
 137         ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
 138                 .setRemoteIp(uni.getIpAddress())
 139                 .setRemotePort(new PortNumber(UnimgrConstants.OVSDB_PORT))
 140                 .build();
 141         OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
 142                 .setConnectionInfo(connectionInfos).build();
 143         return ovsdbNode;
 144     }
 145
 146     public static OvsdbTerminationPointAugmentation createOvsdbTerminationPointAugmentation(Uni uni) {
 147         // we will use nodeId to set interface port id
 148         VlanId vlanID = new VlanId(1);
 149         OvsdbTerminationPointAugmentation terminationPoint = new OvsdbTerminationPointAugmentationBuilder()
 150                                                                      .setName(UnimgrConstants.DEFAULT_INTERNAL_IFACE)
 151                                                                      .setVlanTag(vlanID)
 152                                                                      .setVlanMode(VlanMode.Access)
 153                                                                      .build();
 154         return terminationPoint;
 155     }
 156
 157     public static IpAddress getLocalIp() {
 158         String ip;
 159         try {
 160             ip = InetAddress.getLocalHost().getHostAddress();
 161             Ipv4Address ipv4 = new Ipv4Address(ip);
 162             IpAddress ipAddress = new IpAddress(ipv4);
 163             return ipAddress;
 164         } catch (UnknownHostException e) {
 165             LOG.info("Unable to retrieve controller's ip address, using loopback.");
 166         }
 167         return new IpAddress(UnimgrConstants.LOCAL_IP);
 168     }
 169
 170     public static ConnectionInfo getConnectionInfo(DataBroker dataBroker, NodeId ovsdbNodeId) {
 171         InstanceIdentifier<Node> nodeIid = UnimgrMapper.getOvsdbNodeIID(ovsdbNodeId);
 172         Optional<Node> node = readNode(dataBroker, nodeIid);
 173         if (node.isPresent()) {
 174             Node ovsdbNode = node.get();
 175             OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
 176             ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
 177             return connectionInfo;
 178         } else {
 179             return null;
 180         }
 181     }
 182
 183     public static List<ControllerEntry> createControllerEntries(String targetString) {
 184         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 185         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 186         controllerEntryBuilder.setTarget(new Uri(targetString));
 187         controllerEntries.add(controllerEntryBuilder.build());
 188         return controllerEntries;
 189     }
 190
 191     public static List<ProtocolEntry> createMdsalProtocols() {
 192         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 193         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 194                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 195         protocolList.add(new ProtocolEntryBuilder().
 196                 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
 197         return protocolList;
 198     }
 199
 200     public static void createOvsdbNode(DataBroker dataBroker, NodeId ovsdbNodeId, Uni uni) {
 201         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper
 202                 .getOvsdbNodeIID(uni.getIpAddress());
 203         try {
 204             NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
 205             Node nodeData = new NodeBuilder().setNodeId(ovsdbNodeId)
 206                     .setKey(ovsdbNodeKey)
 207                     .addAugmentation(OvsdbNodeAugmentation.class, UnimgrUtils.createOvsdbNodeAugmentation(uni))
 208                     .build();
 209             // Submit the node to the datastore
 210             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 211             transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid,
 212                     nodeData);
 213             transaction.submit();
 214             LOG.info("Created and submitted a new OVSDB node {}",
 215                     nodeData.getNodeId());
 216         } catch (Exception e) {
 217             LOG.error("Exception while creating OvsdbNodeAugmentation, "
 218                     + "Uni is null. Node Id: {}", ovsdbNodeId);
 219         }
 220     }
 221
 222     public static Node createOvsdbNode(DataBroker dataBroker, UniAugmentation uni) {
 223         List<Node> ovsdbNodes = getOvsdbNodes(dataBroker);
 224         if (!ovsdbNodes.isEmpty()) {
 225             for (Node ovsdbNode: ovsdbNodes) {
 226                 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
 227                         .getAugmentation(OvsdbNodeAugmentation.class);
 228                 if (ovsdbNodeAugmentation.getConnectionInfo()
 229                                          .getRemoteIp().getIpv4Address()
 230                                          .equals(uni.getIpAddress().getIpv4Address())) {
 231                     LOG.info("Found ovsdb node");
 232                     return ovsdbNode;
 233                 }
 234             }
 235         }
 236         return null;
 237     }
 238
 239     public static Node findOvsdbNode(DataBroker dataBroker, UniAugmentation uni) {
 240         List<Node> ovsdbNodes = getOvsdbNodes(dataBroker);
 241         if (!ovsdbNodes.isEmpty()) {
 242             for (Node ovsdbNode: ovsdbNodes) {
 243                 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
 244                         .getAugmentation(OvsdbNodeAugmentation.class);
 245                 if (ovsdbNodeAugmentation.getConnectionInfo()
 246                                          .getRemoteIp().getIpv4Address()
 247                                          .equals(uni.getIpAddress().getIpv4Address())) {
 248                     LOG.info("Found ovsdb node");
 249                     return ovsdbNode;
 250                 }
 251             }
 252         }
 253         return null;
 254     }
 255
 256     public static void updateUniNode(LogicalDatastoreType dataStore,
 257                                InstanceIdentifier<?> uniKey,
 258                                UniAugmentation uni,
 259                                Node ovsdbNode,
 260                                DataBroker dataBroker) {
 261         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 262         UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
 263         Optional<Node> optionalNode = UnimgrUtils.readNode(dataBroker, uniKey);
 264         if (optionalNode.isPresent()) {
 265             Node node = optionalNode.get();
 266             NodeBuilder nodeBuilder = new NodeBuilder();
 267             nodeBuilder.setKey(node.getKey());
 268             nodeBuilder.setNodeId(node.getNodeId());
 269             nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
 270             transaction.put(dataStore, uniKey.firstIdentifierOf(Node.class), nodeBuilder.build());
 271         }
 272     }
 273
 274     @Deprecated
 275     public static void createBridgeNode(DataBroker dataBroker, NodeId ovsdbNodeId, Uni uni, String bridgeName) {
 276         LOG.info("Creating a bridge on node {}", ovsdbNodeId);
 277         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper
 278                 .getOvsdbNodeIID(uni.getIpAddress());
 279         ConnectionInfo connectionInfo = UnimgrUtils.getConnectionInfo(dataBroker, ovsdbNodeId);
 280         if (connectionInfo != null) {
 281             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 282             InstanceIdentifier<Node> bridgeIid = UnimgrMapper
 283                     .getOvsdbBridgeNodeIID(ovsdbNodeId, bridgeName);
 284             NodeId bridgeNodeId = new NodeId(ovsdbNodeId
 285                     + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX + bridgeName);
 286             bridgeNodeBuilder.setNodeId(bridgeNodeId);
 287             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 288             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(
 289                     bridgeName));
 290             ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils
 291                     .createMdsalProtocols());
 292             OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 293             ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 294             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class,
 295                     ovsdbBridgeAugmentationBuilder.build());
 296             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 297             transaction.put(LogicalDatastoreType.CONFIGURATION, bridgeIid,
 298                     bridgeNodeBuilder.build());
 299             transaction.submit();
 300         } else {
 301             LOG.error("The OVSDB node is not connected {}", ovsdbNodeId);
 302         }
 303     }
 304
 305     public static NodeId createOvsdbNodeId(IpAddress ipAddress) {
 306         String nodeId = UnimgrConstants.OVSDB_PREFIX
 307                 + ipAddress.getIpv4Address().getValue().toString()
 308                 + ":"
 309                 + UnimgrConstants.OVSDB_PORT;
 310         return new NodeId(nodeId);
 311     }
 312
 313     public static List<Node> getOvsdbNodes(DataBroker dataBroker) {
 314         List<Node> ovsdbNodes = new ArrayList<>();
 315         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.createTopologyIid();
 316         Topology topology = UnimgrUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
 317         if (topology != null && topology.getNode() != null) {
 318             for (Node node : topology.getNode()) {
 319                 OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 320                 if (ovsdbNodeAugmentation != null) {
 321                     ovsdbNodes.add(node);
 322                 }
 323             }
 324         }
 325         return ovsdbNodes;
 326     }
 327
 328     public static List<Node> getUniNodes(DataBroker dataBroker) {
 329         List<Node> uniNodes = new ArrayList<>();
 330         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.createTopologyIid();
 331         Topology topology = UnimgrUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
 332         if (topology != null && topology.getNode() != null) {
 333             for (Node node : topology.getNode()) {
 334                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 335                 if (uniAugmentation != null) {
 336                     uniNodes.add(node);
 337                 }
 338             }
 339         }
 340         return uniNodes;
 341     }
 342
 343     public static List<Link> getEvcLinks(DataBroker dataBroker, IpAddress ipAddress) {
 344         List<Link> evcLinks = new ArrayList<>();
 345         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.createTopologyIid();
 346         Topology topology = UnimgrUtils.read(dataBroker, LogicalDatastoreType.OPERATIONAL, topologyInstanceIdentifier);
 347         if (topology != null && topology.getNode() != null) {
 348             for (Link link : topology.getLink()) {
 349                 EvcAugmentation evcAugmentation = link.getAugmentation(EvcAugmentation.class);
 350                 if (evcAugmentation != null) {
 351                     evcLinks.add(link);
 352                 }
 353             }
 354         }
 355         return evcLinks;
 356     }
 357
 358     public static void createBridgeNode(DataBroker dataBroker, Node ovsdbNode, UniAugmentation uni, String bridgeName) {
 359         LOG.info("Creating a bridge on node {}", ovsdbNode.getNodeId());
 360         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper
 361                 .getOvsdbNodeIID(uni.getIpAddress());
 362         ConnectionInfo connectionInfo = UnimgrUtils.getConnectionInfo(dataBroker, ovsdbNode.getNodeId());
 363         if (connectionInfo != null) {
 364             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 365             InstanceIdentifier<Node> bridgeIid = UnimgrMapper
 366                     .getOvsdbBridgeNodeIID(ovsdbNode.getNodeId(), bridgeName);
 367             NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId()
 368                     + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX + bridgeName);
 369             bridgeNodeBuilder.setNodeId(bridgeNodeId);
 370             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 371             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(
 372                     bridgeName));
 373             ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils
 374                     .createMdsalProtocols());
 375             OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 376             ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 377             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class,
 378                     ovsdbBridgeAugmentationBuilder.build());
 379             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 380             transaction.put(LogicalDatastoreType.CONFIGURATION, bridgeIid,
 381                     bridgeNodeBuilder.build());
 382             transaction.submit();
 383         } else {
 384             LOG.error("The OVSDB node is not connected {}", ovsdbNode.getNodeId());
 385         }
 386     }
 387
 388     public static void createTerminationPointNode(DataBroker dataBroker, Uni uni,
 389             Node bridgeNode, String bridgeName, String portName, String type) {
 390         InstanceIdentifier<TerminationPoint> tpIid = UnimgrMapper
 391                 .createTerminationPointInstanceIdentifier(bridgeNode, portName);
 392         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 393                 new OvsdbTerminationPointAugmentationBuilder();
 394         tpAugmentationBuilder.setName(portName);
 395         if (type != null) {
 396             tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get(type));
 397         }
 398         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 399         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 400         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 401         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 402         transaction.put(LogicalDatastoreType.CONFIGURATION,tpIid,tpBuilder.build());
 403         transaction.submit();
 404     }
 405
 406     public static void createGreTunnel(DataBroker dataBroker, Uni source, Uni destination,
 407             Node bridgeNode, String bridgeName, String portName) {
 408         InstanceIdentifier<TerminationPoint> tpIid = UnimgrMapper
 409                 .createTerminationPointInstanceIdentifier(bridgeNode, portName);
 410         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 411                 new OvsdbTerminationPointAugmentationBuilder();
 412         tpAugmentationBuilder.setName(portName);
 413         ArrayList<Options> options = Lists.newArrayList();
 414         OptionsKey optionKey = new OptionsKey("remote_ip");
 415         Options destinationIp = new OptionsBuilder()
 416                                         .setOption(destination.getIpAddress().getIpv4Address().getValue())
 417                                         .setKey(optionKey)
 418                                         .setValue(destination.getIpAddress().getIpv4Address().getValue())
 419                                         .build();
 420         options.add(destinationIp);
 421         tpAugmentationBuilder.setOptions(options);
 422         tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get("gre"));
 423         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 424         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 425         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 426         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 427         transaction.put(LogicalDatastoreType.CONFIGURATION,tpIid,tpBuilder.build());
 428         transaction.submit();
 429     }
 430
 431     public static <T extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
 432             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
 433         Set<InstanceIdentifier<T>> result = new HashSet<InstanceIdentifier<T>>();
 434         if (changes != null && changes.getRemovedPaths() != null) {
 435             for (InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
 436                 if (iid.getTargetType().equals(klazz)) {
 437                     @SuppressWarnings("unchecked") // Actually checked above
 438                     InstanceIdentifier<T> iidn = (InstanceIdentifier<T>)iid;
 439                     result.add(iidn);
 440                 }
 441             }
 442         }
 443         return result;
 444     }
 445
 446     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
 447             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
 448         return extract(changes.getOriginalData(),klazz);
 449     }
 450
 451     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
 452             Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
 453         Map<InstanceIdentifier<T>,T> result = new HashMap<InstanceIdentifier<T>,T>();
 454         if (changes != null && changes.entrySet() != null) {
 455             for (Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
 456                 if (klazz.isInstance(created.getValue())) {
 457                     @SuppressWarnings("unchecked")
 458                     T value = (T) created.getValue();
 459                     Class<?> type = created.getKey().getTargetType();
 460                     if (type.equals(klazz)) {
 461                         @SuppressWarnings("unchecked") // Actually checked above
 462                         InstanceIdentifier<T> iid = (InstanceIdentifier<T>) created.getKey();
 463                         result.put(iid, value);
 464                     }
 465                 }
 466             }
 467         }
 468         return result;
 469     }
 470 }