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