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
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  27 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  28 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  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     @Deprecated
  81     public static void createBridgeNode(DataBroker dataBroker,
  82                                         NodeId ovsdbNodeId,
  83                                         Uni uni,
  84                                         String bridgeName) {
  85         LOG.info("Creating a bridge on node {}", ovsdbNodeId);
  86         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper
  87                                                     .getOvsdbNodeIid(uni.getIpAddress());
  88         ConnectionInfo connectionInfo = UnimgrUtils.getConnectionInfo(dataBroker, ovsdbNodeId);
  89         if (connectionInfo != null) {
  90             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
  91             InstanceIdentifier<Node> bridgeIid = UnimgrMapper
  92                                                     .getOvsdbBridgeNodeIid(ovsdbNodeId, bridgeName);
  93             NodeId bridgeNodeId = new NodeId(ovsdbNodeId
  94                                              + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
  95                                              + bridgeName);
  96             bridgeNodeBuilder.setNodeId(bridgeNodeId);
  97             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
  98             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
  99             ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils
 100                                                                 .createMdsalProtocols());
 101             OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 102             ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 103             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class,
 104                                               ovsdbBridgeAugmentationBuilder.build());
 105             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 106             transaction.put(LogicalDatastoreType.CONFIGURATION,
 107                             bridgeIid,
 108                             bridgeNodeBuilder.build());
 109             transaction.submit();
 110         } else {
 111             LOG.error("The OVSDB node is not connected {}", ovsdbNodeId);
 112         }
 113     }
 114
 115     public static void createBridgeNode(DataBroker dataBroker,
 116                                         Node ovsdbNode,
 117                                         UniAugmentation uni,
 118                                         String bridgeName) {
 119         LOG.info("Creating a bridge on node {}", ovsdbNode.getNodeId());
 120         @SuppressWarnings("unchecked")
 121         InstanceIdentifier<Node> ovsdbNodeIid = (InstanceIdentifier<Node>) uni.getOvsdbNodeRef().getValue();
 122         if (ovsdbNodeIid != null) {
 123             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 124             InstanceIdentifier<Node> bridgeIid = UnimgrMapper.getOvsdbBridgeNodeIid(ovsdbNode.getNodeId(),
 125                                                                                     bridgeName);
 126             NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId()
 127                                            + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
 128                                            + bridgeName);
 129             bridgeNodeBuilder.setNodeId(bridgeNodeId);
 130             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 131             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 132             ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils.createMdsalProtocols());
 133             OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 134             ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 135             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 136             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 137             transaction.put(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
 138             transaction.submit();
 139         } else {
 140             LOG.info("OvsdbNodeRef is null");
 141         }
 142     }
 143
 144     public static void createBridgeNode(DataBroker dataBroker,
 145                                         InstanceIdentifier<Node> ovsdbNodeIid,
 146                                         UniAugmentation uni,
 147                                         String bridgeName) {
 148         LOG.info("Creating a bridge on node {}", ovsdbNodeIid);
 149         if (ovsdbNodeIid != null) {
 150             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 151             Optional<Node> optionalOvsdbNode = UnimgrUtils.readNode(dataBroker,
 152                                                                     LogicalDatastoreType.OPERATIONAL,
 153                                                                     ovsdbNodeIid);
 154             if (optionalOvsdbNode.isPresent()) {
 155                 Node ovsdbNode = optionalOvsdbNode.get();
 156                 InstanceIdentifier<Node> bridgeIid = UnimgrMapper.getOvsdbBridgeNodeIid(ovsdbNode.getNodeId(),
 157                                                                                         bridgeName);
 158                 NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId().getValue()
 159                                                + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
 160                                                + bridgeName);
 161                 bridgeNodeBuilder.setNodeId(bridgeNodeId);
 162                 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 163                 ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 164                 ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils.createMdsalProtocols());
 165                 OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 166                 ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 167                 bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class,
 168                                                   ovsdbBridgeAugmentationBuilder.build());
 169                 WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 170                 transaction.put(LogicalDatastoreType.CONFIGURATION,
 171                                 bridgeIid,
 172                                 bridgeNodeBuilder.build());
 173                 transaction.submit();
 174             }
 175         } else {
 176             LOG.info("OvsdbNodeRef is null");
 177         }
 178     }
 179
 180     public static List<ControllerEntry> createControllerEntries(String targetString) {
 181         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 182         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 183         controllerEntryBuilder.setTarget(new Uri(targetString));
 184         controllerEntries.add(controllerEntryBuilder.build());
 185         return controllerEntries;
 186     }
 187
 188     public static void createGreTunnel(DataBroker dataBroker,
 189                                        Uni source,
 190                                        Uni destination,
 191                                        Node bridgeNode,
 192                                        String bridgeName,
 193                                        String portName) {
 194         InstanceIdentifier<TerminationPoint> tpIid =
 195                                                  UnimgrMapper.getTerminationPointIid(bridgeNode,
 196                                                                                      portName);
 197         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 198                                                      new OvsdbTerminationPointAugmentationBuilder();
 199         tpAugmentationBuilder.setName(portName);
 200         ArrayList<Options> options = Lists.newArrayList();
 201         OptionsKey optionKey = new OptionsKey("remote_ip");
 202         Options destinationIp = new OptionsBuilder()
 203                                         .setOption(destination.getIpAddress().getIpv4Address().getValue())
 204                                         .setKey(optionKey).setValue(destination.getIpAddress().getIpv4Address().getValue())
 205                                         .build();
 206         options.add(destinationIp);
 207         tpAugmentationBuilder.setOptions(options);
 208         tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get("gre"));
 209         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 210         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 211         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 212         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 213         transaction.put(LogicalDatastoreType.CONFIGURATION,
 214                         tpIid,
 215                         tpBuilder.build());
 216         transaction.submit();
 217     }
 218
 219     public static List<ProtocolEntry> createMdsalProtocols() {
 220         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 221         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 222                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 223         protocolList.add(new ProtocolEntryBuilder().
 224                 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
 225         return protocolList;
 226     }
 227
 228     public static OvsdbBridgeAugmentation createOvsdbBridgeAugmentation(Uni uni) throws Exception {
 229         OvsdbNodeRef ovsdbNodeRef = uni.getOvsdbNodeRef();
 230         if (ovsdbNodeRef != null && ovsdbNodeRef.getValue() != null) {
 231             UUID bridgeUuid = UUID.randomUUID();
 232             OvsdbBridgeAugmentation ovsdbBridge = new OvsdbBridgeAugmentationBuilder()
 233                                                         .setBridgeName(
 234                                                                 new OvsdbBridgeName(UnimgrConstants.DEFAULT_BRIDGE_NAME))
 235                                                         .setManagedBy(ovsdbNodeRef)
 236                                                         .setBridgeUuid(
 237                                                                 new Uuid(bridgeUuid.toString()))
 238                                                         .build();
 239             return ovsdbBridge;
 240         } else {
 241             throw new Exception("Ovsdb Node Reference does not exist !");
 242         }
 243     }
 244
 245     public static void createOvsdbNode(DataBroker dataBroker,
 246                                        NodeId ovsdbNodeId,
 247                                        Uni uni) {
 248         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(uni.getIpAddress());
 249         try {
 250             NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
 251             Node nodeData = new NodeBuilder()
 252                                     .setNodeId(ovsdbNodeId)
 253                                     .setKey(ovsdbNodeKey)
 254                                     .addAugmentation(OvsdbNodeAugmentation.class,
 255                                                      UnimgrUtils.createOvsdbNodeAugmentation(uni))
 256                                     .build();
 257             // Submit the node to the datastore
 258             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 259             transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid, nodeData);
 260             transaction.submit();
 261             LOG.info("Created and submitted a new OVSDB node {}", nodeData.getNodeId());
 262         } catch (Exception e) {
 263             LOG.error("Exception while creating OvsdbNodeAugmentation, " + "Uni is null. Node Id: {}", ovsdbNodeId);
 264         }
 265     }
 266
 267     public static Node createOvsdbNode(DataBroker dataBroker,
 268                                        UniAugmentation uni) {
 269         NodeId ovsdbNodeId = new NodeId(createOvsdbNodeId(uni.getIpAddress()));
 270         try {
 271             InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNodeId);
 272             NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
 273             Node nodeData = new NodeBuilder()
 274                                     .setNodeId(ovsdbNodeId)
 275                                     .setKey(ovsdbNodeKey)
 276                                     .addAugmentation(OvsdbNodeAugmentation.class,
 277                                                      UnimgrUtils.createOvsdbNodeAugmentation(uni))
 278                                     .build();
 279             // Submit the node to the datastore
 280             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 281             transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid, nodeData);
 282             transaction.submit();
 283             LOG.info("Created and submitted a new OVSDB node {}", nodeData.getNodeId());
 284             return nodeData;
 285         } catch (Exception e) {
 286             LOG.error("Exception while creating OvsdbNodeAugmentation, " + "Uni is null. Node Id: {}", ovsdbNodeId);
 287         }
 288         return null;
 289     }
 290
 291     public static OvsdbNodeAugmentation createOvsdbNodeAugmentation(Uni uni) {
 292         ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
 293                                                 .setRemoteIp(uni.getIpAddress())
 294                                                 .setRemotePort(new PortNumber(UnimgrConstants.OVSDB_PORT))
 295                                                 .build();
 296         OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
 297                                                 .setConnectionInfo(connectionInfos).build();
 298         return ovsdbNode;
 299     }
 300
 301     public static NodeId createOvsdbNodeId(IpAddress ipAddress) {
 302         String nodeId = UnimgrConstants.OVSDB_PREFIX
 303                         + ipAddress.getIpv4Address().getValue().toString()
 304                         + ":"
 305                         + UnimgrConstants.OVSDB_PORT;
 306         return new NodeId(nodeId);
 307     }
 308
 309     public static OvsdbTerminationPointAugmentation createOvsdbTerminationPointAugmentation(Uni uni) {
 310         // we will use nodeId to set interface port id
 311         VlanId vlanID = new VlanId(1);
 312         OvsdbTerminationPointAugmentation terminationPoint = new OvsdbTerminationPointAugmentationBuilder()
 313                                                                      .setName(UnimgrConstants.DEFAULT_INTERNAL_IFACE)
 314                                                                      .setVlanTag(vlanID)
 315                                                                      .setVlanMode(VlanMode.Access)
 316                                                                      .build();
 317         return terminationPoint;
 318     }
 319
 320     public static void createTerminationPointNode(DataBroker dataBroker,
 321                                                   Uni uni,
 322                                                   Node bridgeNode,
 323                                                   String bridgeName,
 324                                                   String portName,
 325                                                   String type) {
 326         InstanceIdentifier<TerminationPoint> tpIid = UnimgrMapper
 327                                                         .getTerminationPointIid(bridgeNode,
 328                                                                                 portName);
 329         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 330         tpAugmentationBuilder.setName(portName);
 331         if (type != null) {
 332             tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get(type));
 333         }
 334         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 335         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 336         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class,
 337                                   tpAugmentationBuilder.build());
 338         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 339         transaction.put(LogicalDatastoreType.CONFIGURATION,
 340                         tpIid,
 341                         tpBuilder.build());
 342         transaction.submit();
 343     }
 344
 345     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
 346             Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
 347         Map<InstanceIdentifier<T>,T> result = new HashMap<InstanceIdentifier<T>,T>();
 348         if (changes != null && changes.entrySet() != null) {
 349             for (Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
 350                 if (klazz.isInstance(created.getValue())) {
 351                     @SuppressWarnings("unchecked")
 352                     T value = (T) created.getValue();
 353                     Class<?> type = created.getKey().getTargetType();
 354                     if (type.equals(klazz)) {
 355                         @SuppressWarnings("unchecked") // Actually checked above
 356                         InstanceIdentifier<T> iid = (InstanceIdentifier<T>) created.getKey();
 357                         result.put(iid, value);
 358                     }
 359                 }
 360             }
 361         }
 362         return result;
 363     }
 364
 365     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
 366             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
 367         return extract(changes.getOriginalData(),klazz);
 368     }
 369
 370     public static <T extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
 371             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
 372         Set<InstanceIdentifier<T>> result = new HashSet<InstanceIdentifier<T>>();
 373         if (changes != null && changes.getRemovedPaths() != null) {
 374             for (InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
 375                 if (iid.getTargetType().equals(klazz)) {
 376                     @SuppressWarnings("unchecked") // Actually checked above
 377                     InstanceIdentifier<T> iidn = (InstanceIdentifier<T>)iid;
 378                     result.add(iidn);
 379                 }
 380             }
 381         }
 382         return result;
 383     }
 384
 385     public static Optional<Node> findOvsdbNode(DataBroker dataBroker,
 386                                                UniAugmentation uni) {
 387         List<Node> ovsdbNodes = getOvsdbNodes(dataBroker);
 388         Optional<Node> optionalOvsdb;
 389         if (!ovsdbNodes.isEmpty()) {
 390             for (Node ovsdbNode : ovsdbNodes) {
 391                 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
 392                                                                   .getAugmentation(OvsdbNodeAugmentation.class);
 393                 if (ovsdbNodeAugmentation.getConnectionInfo()
 394                                          .getRemoteIp()
 395                                          .getIpv4Address()
 396                         .equals(uni.getIpAddress().getIpv4Address())) {
 397                     LOG.info("Found ovsdb node");
 398                     optionalOvsdb = Optional.of(ovsdbNode);
 399                     return optionalOvsdb;
 400                 }
 401             }
 402         }
 403         return Optional.absent();
 404     }
 405
 406     public static Optional<Node> findUniNode(DataBroker dataBroker,
 407                                              IpAddress ipAddress) {
 408         List<Node> uniNodes = getUniNodes(dataBroker);
 409         if (!uniNodes.isEmpty()) {
 410             for (Node uniNode : uniNodes) {
 411                 UniAugmentation uniAugmentation = uniNode.getAugmentation(UniAugmentation.class);
 412                 if (uniAugmentation.getIpAddress().equals(ipAddress)) {
 413                     LOG.info("Found Uni node");
 414                     return Optional.of(uniNode);
 415                 }
 416             }
 417         }
 418         return Optional.absent();
 419     }
 420
 421     public static ConnectionInfo getConnectionInfo(DataBroker dataBroker,
 422                                                    NodeId ovsdbNodeId) {
 423         InstanceIdentifier<Node> nodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNodeId);
 424         Optional<Node> node = readNode(dataBroker,
 425                                        LogicalDatastoreType.OPERATIONAL,
 426                                        nodeIid);
 427         if (node.isPresent()) {
 428             Node ovsdbNode = node.get();
 429             OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
 430                                                               .getAugmentation(OvsdbNodeAugmentation.class);
 431             ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
 432             return connectionInfo;
 433         } else {
 434             return null;
 435         }
 436     }
 437
 438     public static List<Link> getEvcLinks(DataBroker dataBroker,
 439                                          IpAddress ipAddress) {
 440         List<Link> evcLinks = new ArrayList<>();
 441         InstanceIdentifier<Topology> evcTopology = UnimgrMapper.getEvcTopologyIid();
 442         Topology topology = UnimgrUtils.read(dataBroker,
 443                                              LogicalDatastoreType.OPERATIONAL,
 444                                              evcTopology);
 445         if (topology != null && topology.getLink() != null) {
 446             for (Link link : topology.getLink()) {
 447                 EvcAugmentation evcAugmentation = link.getAugmentation(EvcAugmentation.class);
 448                 if (evcAugmentation != null) {
 449                     evcLinks.add(link);
 450                 }
 451             }
 452         }
 453         return evcLinks;
 454     }
 455
 456     public static IpAddress getLocalIp() {
 457         String ip;
 458         try {
 459             ip = InetAddress.getLocalHost().getHostAddress();
 460             Ipv4Address ipv4 = new Ipv4Address(ip);
 461             IpAddress ipAddress = new IpAddress(ipv4);
 462             return ipAddress;
 463         } catch (UnknownHostException e) {
 464             LOG.info("Unable to retrieve controller's ip address, using loopback.");
 465         }
 466         return new IpAddress(UnimgrConstants.LOCAL_IP);
 467     }
 468
 469     public static List<Node> getOvsdbNodes(DataBroker dataBroker) {
 470         List<Node> ovsdbNodes = new ArrayList<>();
 471         InstanceIdentifier<Topology> ovsdbTopoIdentifier = UnimgrMapper.getOvsdbTopologyIid();
 472         Topology topology = UnimgrUtils.read(dataBroker,
 473                                              LogicalDatastoreType.OPERATIONAL,
 474                                              ovsdbTopoIdentifier);
 475         if (topology != null && topology.getNode() != null) {
 476             for (Node node : topology.getNode()) {
 477                 OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 478                 if (ovsdbNodeAugmentation != null) {
 479                     ovsdbNodes.add(node);
 480                 }
 481             }
 482         }
 483         return ovsdbNodes;
 484     }
 485
 486     public static List<Node> getUniNodes(DataBroker dataBroker) {
 487         List<Node> uniNodes = new ArrayList<>();
 488         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
 489         Topology topology = read(dataBroker,
 490                                  LogicalDatastoreType.CONFIGURATION,
 491                                  topologyInstanceIdentifier);
 492         if (topology != null && topology.getNode() != null) {
 493             for (Node node : topology.getNode()) {
 494                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 495                 if (uniAugmentation != null) {
 496                     uniNodes.add(node);
 497                 }
 498             }
 499         }
 500         return uniNodes;
 501     }
 502
 503     public static List<Node> getUniNodes(DataBroker dataBroker,
 504                                          LogicalDatastoreType store) {
 505         List<Node> uniNodes = new ArrayList<>();
 506         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
 507         Topology topology = read(dataBroker,
 508                                  store,
 509                                  topologyInstanceIdentifier);
 510         if (topology != null && topology.getNode() != null) {
 511             for (Node node : topology.getNode()) {
 512                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 513                 if (uniAugmentation != null) {
 514                     uniNodes.add(node);
 515                 }
 516             }
 517         }
 518         return uniNodes;
 519     }
 520
 521     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
 522             DataBroker dataBroker,
 523             final LogicalDatastoreType store,
 524             final InstanceIdentifier<D> path)  {
 525         D result = null;
 526         final ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
 527         Optional<D> optionalDataObject;
 528         CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
 529         try {
 530             optionalDataObject = future.checkedGet();
 531             if (optionalDataObject.isPresent()) {
 532                 result = optionalDataObject.get();
 533             } else {
 534                 LOG.debug("{}: Failed to read {}",
 535                         Thread.currentThread().getStackTrace()[1], path);
 536             }
 537         } catch (ReadFailedException e) {
 538             LOG.warn("Failed to read {} ", path, e);
 539         }
 540         transaction.close();
 541         return result;
 542     }
 543
 544     @Deprecated
 545     public static final Optional<Node> readNode(DataBroker dataBroker,
 546                                                 InstanceIdentifier<?> genericNode) {
 547         ReadTransaction read = dataBroker.newReadOnlyTransaction();
 548         InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
 549         CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
 550                                                               read.read(LogicalDatastoreType.OPERATIONAL,
 551                                                                         nodeIid);
 552         try {
 553             return nodeFuture.checkedGet();
 554         } catch (ReadFailedException e) {
 555             LOG.info("Unable to read node with Iid {}", nodeIid);
 556         }
 557         return Optional.absent();
 558     }
 559
 560     public static final Optional<Node> readNode(DataBroker dataBroker,
 561                                                 LogicalDatastoreType store,
 562                                                 InstanceIdentifier<?> genericNode) {
 563         ReadTransaction read = dataBroker.newReadOnlyTransaction();
 564         InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
 565         CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = read
 566                 .read(store, nodeIid);
 567         try {
 568             return nodeFuture.checkedGet();
 569         } catch (ReadFailedException e) {
 570             LOG.info("Unable to read node with Iid {}", nodeIid);
 571         }
 572         return Optional.absent();
 573     }
 574
 575     public static void updateUniNode(LogicalDatastoreType dataStore,
 576                                      InstanceIdentifier<?> uniKey,
 577                                      UniAugmentation uni,
 578                                      Node ovsdbNode,
 579                                      DataBroker dataBroker) {
 580         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNode.getNodeId());
 581         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 582         UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
 583         if (ovsdbNodeRef != null) {
 584             updatedUniBuilder.setOvsdbNodeRef(ovsdbNodeRef);
 585         }
 586         Optional<Node> optionalNode = readNode(dataBroker,
 587                                                LogicalDatastoreType.CONFIGURATION,
 588                                                uniKey);
 589         if (optionalNode.isPresent()) {
 590             Node node = optionalNode.get();
 591             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 592             NodeBuilder nodeBuilder = new NodeBuilder();
 593             nodeBuilder.setKey(node.getKey());
 594             nodeBuilder.setNodeId(node.getNodeId());
 595             nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
 596             transaction.put(dataStore, uniKey.firstIdentifierOf(Node.class), nodeBuilder.build());
 597             transaction.submit();
 598         }
 599     }
 600
 601     public static void updateUniNode(LogicalDatastoreType dataStore,
 602                                      InstanceIdentifier<?> uniKey,
 603                                      UniAugmentation uni,
 604                                      InstanceIdentifier<?> ovsdbNodeIid,
 605                                      DataBroker dataBroker) {
 606         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 607         UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
 608         if (ovsdbNodeRef != null) {
 609             updatedUniBuilder.setOvsdbNodeRef(ovsdbNodeRef);
 610         }
 611         Optional<Node> optionalNode = readNode(dataBroker,
 612                                                LogicalDatastoreType.CONFIGURATION,
 613                                                uniKey);
 614         if (optionalNode.isPresent()) {
 615             Node node = optionalNode.get();
 616             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 617             NodeBuilder nodeBuilder = new NodeBuilder();
 618             nodeBuilder.setKey(node.getKey());
 619             nodeBuilder.setNodeId(node.getNodeId());
 620             nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
 621             transaction.put(dataStore, uniKey.firstIdentifierOf(Node.class), nodeBuilder.build());
 622             transaction.submit();
 623         }
 624     }
 625 }