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