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.EvcAugmentation;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.EvcAugmentationBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.Uni;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentation;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentationBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDest;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDestBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDestKey;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSource;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSourceBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSourceKey;
  66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
  71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  75 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  77 import org.opendaylight.yangtools.yang.binding.DataObject;
  78 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  79 import org.slf4j.Logger;
  80 import org.slf4j.LoggerFactory;
  81
  82 import com.google.common.base.Optional;
  83 import com.google.common.collect.ImmutableBiMap;
  84 import com.google.common.collect.Lists;
  85 import com.google.common.util.concurrent.CheckedFuture;
  86
  87 public class UnimgrUtils {
  88
  89     private static final Logger LOG = LoggerFactory.getLogger(UnimgrUtils.class);
  90
  91     /**
  92      * Creates and submit a Bridge Node to the Configuration Data Store.
  93      * @param dataBroker The Data Broker Instance to create a transaction
  94      * @param ovsdbNode The OVSDB node
  95      * @param uni The UNI linked to the OVSDB node
  96      * @param bridgeName The bridge name (example: br0)
  97      */
  98     public static void createBridgeNode(DataBroker dataBroker,
  99                                         Node ovsdbNode,
 100                                         UniAugmentation uni,
 101                                         String bridgeName) {
 102         LOG.info("Creating a bridge on node {}", ovsdbNode.getNodeId().getValue());
 103         InstanceIdentifier<Node> ovsdbNodeIid = uni.getOvsdbNodeRef().getValue().firstIdentifierOf(Node.class);
 104         if (ovsdbNodeIid != null) {
 105             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 106             InstanceIdentifier<Node> bridgeIid = UnimgrMapper.createOvsdbBridgeNodeIid(ovsdbNode,
 107                                                                                        bridgeName);
 108             NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId()
 109                                            + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
 110                                            + bridgeName);
 111             bridgeNodeBuilder.setNodeId(bridgeNodeId);
 112             OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 113             ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 114             ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils.createMdsalProtocols());
 115             OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 116             ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 117             bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
 118             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 119             transaction.put(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
 120             transaction.submit();
 121         } else {
 122             LOG.info("OvsdbNodeRef is null");
 123         }
 124     }
 125
 126     /**
 127      * Creates and submit a Bridge Node to the Configuration Data Store.
 128      * @param dataBroker The Data Broker Instance to create a transaction
 129      * @param ovsdbNodeIid The OVSDB node Instance Identifier
 130      * @param uni The UNI linked to the OVSDB node
 131      * @param bridgeName The bridge name (example: br0)
 132      */
 133     public static void createBridgeNode(DataBroker dataBroker,
 134                                         InstanceIdentifier<Node> ovsdbNodeIid,
 135                                         UniAugmentation uni,
 136                                         String bridgeName) {
 137         LOG.info("Creating a bridge on node {}", ovsdbNodeIid);
 138         if (ovsdbNodeIid != null) {
 139             NodeBuilder bridgeNodeBuilder = new NodeBuilder();
 140             Optional<Node> optionalOvsdbNode = UnimgrUtils.readNode(dataBroker,
 141                                                                     LogicalDatastoreType.OPERATIONAL,
 142                                                                     ovsdbNodeIid);
 143             if (optionalOvsdbNode.isPresent()) {
 144                 Node ovsdbNode = optionalOvsdbNode.get();
 145                 InstanceIdentifier<Node> bridgeIid = UnimgrMapper.createOvsdbBridgeNodeIid(ovsdbNode,
 146                                                                                            bridgeName);
 147                 NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId().getValue()
 148                                                + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
 149                                                + bridgeName);
 150                 bridgeNodeBuilder.setNodeId(bridgeNodeId);
 151                 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 152                 ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
 153                 ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils.createMdsalProtocols());
 154                 OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 155                 ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
 156                 bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class,
 157                                                   ovsdbBridgeAugmentationBuilder.build());
 158                 WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 159                 transaction.put(LogicalDatastoreType.CONFIGURATION,
 160                                 bridgeIid,
 161                                 bridgeNodeBuilder.build());
 162                 transaction.submit();
 163             }
 164         } else {
 165             LOG.info("OvsdbNodeRef is null");
 166         }
 167     }
 168
 169     /**
 170      * Creates a List of Controller Entry to be used when adding controllers
 171      * to a Bridge.
 172      * @param targetString The URI in string format of the Controller Entry
 173      * @return A List of Controller Entry to be used when adding controllers
 174      */
 175     public static List<ControllerEntry> createControllerEntries(String targetString) {
 176         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 177         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 178         controllerEntryBuilder.setTarget(new Uri(targetString));
 179         controllerEntries.add(controllerEntryBuilder.build());
 180         return controllerEntries;
 181     }
 182
 183     /**
 184      * Creates a submit a GRE tunnel to the Configuration DataStore.
 185      * @param dataBroker An instance of the Data Broker to create a transaction
 186      * @param source The source UNI
 187      * @param destination The destination UNI
 188      * @param bridgeNode The bridge Node
 189      * @param bridgeName The bridge name (example br0)
 190      * @param portName The Port Name (example: eth0)
 191      */
 192     public static void createGreTunnel(DataBroker dataBroker,
 193                                        Uni source,
 194                                        Uni destination,
 195                                        Node bridgeNode,
 196                                        String bridgeName,
 197                                        String portName) {
 198         InstanceIdentifier<TerminationPoint> tpIid =
 199                                                  UnimgrMapper.getTerminationPointIid(bridgeNode,
 200                                                                                      portName);
 201         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 202                                                      new OvsdbTerminationPointAugmentationBuilder();
 203         tpAugmentationBuilder.setName(portName);
 204         ArrayList<Options> options = Lists.newArrayList();
 205         OptionsKey optionKey = new OptionsKey("remote_ip");
 206         Options destinationIp = new OptionsBuilder()
 207                                         .setOption(destination.getIpAddress().getIpv4Address().getValue())
 208                                         .setKey(optionKey).setValue(destination.getIpAddress().getIpv4Address().getValue())
 209                                         .build();
 210         options.add(destinationIp);
 211         tpAugmentationBuilder.setOptions(options);
 212         tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get("gre"));
 213         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 214         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 215         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 216         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 217         transaction.put(LogicalDatastoreType.CONFIGURATION,
 218                         tpIid,
 219                         tpBuilder.build());
 220         transaction.submit();
 221     }
 222
 223     /**
 224      * Utility function used to create a protocol entry when creating a bridge node.
 225      * @return A List of protocol entry
 226      */
 227     public static List<ProtocolEntry> createMdsalProtocols() {
 228         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 229         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 230                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 231         protocolList.add(new ProtocolEntryBuilder().
 232                 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
 233         return protocolList;
 234     }
 235
 236     /**
 237      * Creates a Bridge Augmentation by using a UNI
 238      * @param uni Contains data used to create the augmentation
 239      * @return A Built OvsdbBridgeAugmentation with data.
 240      * @throws Exception if the Ovsdb Node Reference cannot be found.
 241      */
 242     public static OvsdbBridgeAugmentation createOvsdbBridgeAugmentation(Uni uni) throws Exception {
 243         OvsdbNodeRef ovsdbNodeRef = uni.getOvsdbNodeRef();
 244         if (ovsdbNodeRef != null && ovsdbNodeRef.getValue() != null) {
 245             UUID bridgeUuid = UUID.randomUUID();
 246             OvsdbBridgeAugmentation ovsdbBridge = new OvsdbBridgeAugmentationBuilder()
 247                                                         .setBridgeName(
 248                                                                 new OvsdbBridgeName(UnimgrConstants.DEFAULT_BRIDGE_NAME))
 249                                                         .setManagedBy(ovsdbNodeRef)
 250                                                         .setBridgeUuid(
 251                                                                 new Uuid(bridgeUuid.toString()))
 252                                                         .build();
 253             return ovsdbBridge;
 254         } else {
 255             throw new Exception("Ovsdb Node Reference does not exist !");
 256         }
 257     }
 258
 259     /**
 260      * Creates a submit an OvsdbNode to the Configuration DataStore.
 261      * @param dataBroker The instance of the Data Broker to create transactions.
 262      * @param ovsdbNodeId The Ovsdb Node Id to use on creation
 263      * @param uni The UNI's data
 264      */
 265     public static void createOvsdbNode(DataBroker dataBroker,
 266                                        NodeId ovsdbNodeId,
 267                                        Uni uni) {
 268         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(uni.getIpAddress());
 269         try {
 270             NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
 271             Node nodeData = new NodeBuilder()
 272                                     .setNodeId(ovsdbNodeId)
 273                                     .setKey(ovsdbNodeKey)
 274                                     .addAugmentation(OvsdbNodeAugmentation.class,
 275                                                      UnimgrUtils.createOvsdbNodeAugmentation(uni))
 276                                     .build();
 277             // Submit the node to the datastore
 278             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 279             transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid, nodeData);
 280             transaction.submit();
 281             LOG.info("Created and submitted a new OVSDB node {}", nodeData.getNodeId());
 282         } catch (Exception e) {
 283             LOG.error("Exception while creating OvsdbNodeAugmentation, " + "Uni is null. Node Id: {}", ovsdbNodeId);
 284         }
 285     }
 286
 287     /**
 288      * Creates and submit an OvsdbNode by using the Data contained in the UniAugmentation
 289      * @param dataBroker The instance of the DataBroker to create transactions
 290      * @param uni The UNI's data
 291      * @return The instance of the Node
 292      */
 293     public static Node createOvsdbNode(DataBroker dataBroker,
 294                                        UniAugmentation uni) {
 295         NodeId ovsdbNodeId = new NodeId(createOvsdbNodeId(uni.getIpAddress()));
 296         try {
 297             InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNodeId);
 298             NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
 299             Node nodeData = new NodeBuilder()
 300                                     .setNodeId(ovsdbNodeId)
 301                                     .setKey(ovsdbNodeKey)
 302                                     .addAugmentation(OvsdbNodeAugmentation.class,
 303                                                      UnimgrUtils.createOvsdbNodeAugmentation(uni))
 304                                     .build();
 305             // Submit the node to the datastore
 306             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 307             transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid, nodeData);
 308             transaction.submit();
 309             LOG.info("Created and submitted a new OVSDB node {}", nodeData.getNodeId());
 310             return nodeData;
 311         } catch (Exception e) {
 312             LOG.error("Exception while creating OvsdbNodeAugmentation, " + "Uni is null. Node Id: {}", ovsdbNodeId);
 313         }
 314         return null;
 315     }
 316
 317     /**
 318      * Creates and Build the data for an OvsdbNodeAugmentation.
 319      * @param uni The UNI"s data
 320      * @return The built OsvdbNodeAugmentation
 321      */
 322     public static OvsdbNodeAugmentation createOvsdbNodeAugmentation(Uni uni) {
 323         ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
 324                                                 .setRemoteIp(uni.getIpAddress())
 325                                                 .setRemotePort(new PortNumber(UnimgrConstants.OVSDB_PORT))
 326                                                 .build();
 327         OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
 328                                                 .setConnectionInfo(connectionInfos).build();
 329         return ovsdbNode;
 330     }
 331
 332     /**
 333      * Creates an OVSDB node Id with an IP Address.
 334      * @param ipAddress The IP address of the UNI (therefo the OVSDB node)
 335      * @return A NodeId for a Specific Ovsdb Node Id
 336      */
 337     public static NodeId createOvsdbNodeId(IpAddress ipAddress) {
 338         String nodeId = UnimgrConstants.OVSDB_PREFIX
 339                         + ipAddress.getIpv4Address().getValue().toString()
 340                         + ":"
 341                         + UnimgrConstants.OVSDB_PORT;
 342         return new NodeId(nodeId);
 343     }
 344
 345     /**
 346      * Creates a built OvsdbTerminationAugmentation with data
 347      * @param uni The UNI's data
 348      * @return A Built OvsdbTerminationPointAugmentation with data
 349      */
 350     public static OvsdbTerminationPointAugmentation createOvsdbTerminationPointAugmentation(Uni uni) {
 351         // we will use nodeId to set interface port id
 352         VlanId vlanID = new VlanId(1);
 353         OvsdbTerminationPointAugmentation terminationPoint = new OvsdbTerminationPointAugmentationBuilder()
 354                                                                      .setName(UnimgrConstants.DEFAULT_INTERNAL_IFACE)
 355                                                                      .setVlanTag(vlanID)
 356                                                                      .setVlanMode(VlanMode.Access)
 357                                                                      .build();
 358         return terminationPoint;
 359     }
 360
 361     /**
 362      * Creates and submit an UNI Node by using the Data contained in the UniAugmentation
 363      * @param dataBroker The instance of the DataBroker to create transactions
 364      * @param uni The UNI's data
 365      * @return The instance of the UNI Node
 366      */
 367     public static boolean createUniNode(DataBroker dataBroker, UniAugmentation uni) {
 368         NodeId uniNodeId = new NodeId(createUniNodeId(uni.getIpAddress()));
 369         boolean result = false;
 370         try {
 371             InstanceIdentifier<Node> uniNodeIid = UnimgrMapper.getUniNodeIid(uniNodeId);
 372             NodeKey uniNodeKey = new NodeKey(uniNodeId);
 373             Node nodeData = new NodeBuilder()
 374                                 .setNodeId(uniNodeId)
 375                                 .setKey(uniNodeKey)
 376                                 .addAugmentation(UniAugmentation.class, uni)
 377                                 .build();
 378             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 379             transaction.put(LogicalDatastoreType.CONFIGURATION, uniNodeIid, nodeData);
 380             CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 381             future.checkedGet();
 382             result = true;
 383             LOG.info("Created and submitted a new Uni node {}", nodeData.getNodeId());
 384         } catch (Exception e) {
 385             LOG.error("Exception while creating Uni Node" + "Uni Node Id: {}", uniNodeId);
 386         }
 387         return result;
 388     }
 389
 390     /**
 391      * Creates an UNI node Id with an IP Address.
 392      * @param ipAddress The IP address of the UNI
 393      * @return A NodeId for a Specific UNI Node Id
 394      */
 395     public static NodeId createUniNodeId(IpAddress ipAddress) {
 396         return new NodeId(UnimgrConstants.UNI_PREFIX + ipAddress.getIpv4Address().getValue().toString());
 397     }
 398
 399     /**
 400      * Creates and Submit a termination point Node to the configuration DateStore.
 401      * @param dataBroker The instance of the data broker to create transactions
 402      * @param uni The UNI's data
 403      * @param bridgeNode The Bridge node
 404      * @param bridgeName The Bridge name (example: br0)
 405      * @param portName The Port name (example: eth0)
 406      * @param type The type of termination (example: gre) Refer to OVSDB_INTERFACE_TYPE_MAP
 407      * to review the list of available Interface Types.
 408      */
 409     public static void createTerminationPointNode(DataBroker dataBroker,
 410                                                   Uni uni,
 411                                                   Node bridgeNode,
 412                                                   String bridgeName,
 413                                                   String portName,
 414                                                   String type) {
 415         InstanceIdentifier<TerminationPoint> tpIid = UnimgrMapper
 416                                                         .getTerminationPointIid(bridgeNode,
 417                                                                                 portName);
 418         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
 419                                                      new OvsdbTerminationPointAugmentationBuilder();
 420         tpAugmentationBuilder.setName(portName);
 421         if (type != null) {
 422             tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get(type));
 423         }
 424         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 425         tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
 426         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class,
 427                                   tpAugmentationBuilder.build());
 428         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 429         transaction.put(LogicalDatastoreType.CONFIGURATION,
 430                         tpIid,
 431                         tpBuilder.build());
 432         transaction.submit();
 433     }
 434
 435     /**
 436      * Deletes a generic node
 437      * @param dataBroker The instance of the data broker to create transactions
 438      * @param store The DataStore where the delete
 439      * @param path The path to delete
 440      * @return An instance of a generic Data Object
 441      */
 442     public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
 443             DataBroker dataBroker,
 444             final LogicalDatastoreType store,
 445             final InstanceIdentifier<D> path)  {
 446         boolean result = false;
 447         final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 448         transaction.delete(store, path);
 449         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 450         try {
 451             future.checkedGet();
 452             result = true;
 453         } catch (TransactionCommitFailedException e) {
 454             LOG.warn("Failed to delete {} ", path, e);
 455         }
 456         return result;
 457     }
 458
 459     /**
 460      * Deletes a termination Point from the configuration data store.
 461      * @param dataBroker The instance of the data broker to create transactions
 462      * @param terminationPoint The Termination Point of the OVSDB bridge
 463      * @param ovsdbNode The ovsdb Node
 464      * @return A checked Future
 465      */
 466     public static CheckedFuture<Void,
 467                                 TransactionCommitFailedException>
 468                                 deleteTerminationPoint(DataBroker dataBroker,
 469                                                        TerminationPoint terminationPoint,
 470                                                        Node ovsdbNode) {
 471         InstanceIdentifier<TerminationPoint> terminationPointPath =
 472                                                  InstanceIdentifier
 473                                                      .create(NetworkTopology.class)
 474                                                      .child(Topology.class,
 475                                                              new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 476                                                      .child(Node.class,
 477                                                             ovsdbNode.getKey())
 478                                                      .child(TerminationPoint.class,
 479                                                             terminationPoint.getKey());
 480         final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 481         transaction.delete(LogicalDatastoreType.CONFIGURATION, terminationPointPath);
 482         transaction.delete(LogicalDatastoreType.OPERATIONAL, terminationPointPath);
 483         transaction.submit();
 484         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
 485         return future;
 486     }
 487
 488     /**
 489      * Generic function to delete a node on a specific dataStore
 490      * @param dataBroker The instance of the data broker to create transactions.
 491      * @param genericNode The instance identifier of a generic node
 492      * @param store The dataStore where to send and submit the delete call.
 493      */
 494     public static boolean deleteNode(DataBroker dataBroker,
 495                                   InstanceIdentifier<?> genericNode,
 496                                   LogicalDatastoreType store) {
 497         LOG.info("Received a request to delete node {}", genericNode);
 498         boolean result = false;
 499         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 500         transaction.delete(store, genericNode);
 501         try {
 502             transaction.submit().checkedGet();
 503             return !result;
 504         } catch (TransactionCommitFailedException e) {
 505             LOG.error("Unable to remove node with Iid {} from store {}.", genericNode, store);
 506         }
 507         return result;
 508     }
 509
 510     /**
 511      * Extract a data object by using its instance indentifier and it's class type.
 512      * @param changes Data Change object
 513      * @param klazz Class type
 514      * @return The extracted DataObject as an Object casted as the class type
 515      */
 516     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
 517             Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
 518         Map<InstanceIdentifier<T>,T> result = new HashMap<InstanceIdentifier<T>,T>();
 519         if (changes != null && changes.entrySet() != null) {
 520             for (Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
 521                 if (klazz.isInstance(created.getValue())) {
 522                     @SuppressWarnings("unchecked")
 523                     T value = (T) created.getValue();
 524                     Class<?> type = created.getKey().getTargetType();
 525                     if (type.equals(klazz)) {
 526                         @SuppressWarnings("unchecked") // Actually checked above
 527                         InstanceIdentifier<T> iid = (InstanceIdentifier<T>) created.getKey();
 528                         result.put(iid, value);
 529                     }
 530                 }
 531             }
 532         }
 533         return result;
 534     }
 535
 536     /**
 537      * Extract original data from the data store.
 538      * @param changes The dataChange object
 539      * @param klazz The class type
 540      * @return The DataObject casted as a Class type
 541      */
 542     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
 543             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
 544         return extract(changes.getOriginalData(),klazz);
 545     }
 546
 547     /**
 548      * Extracts the removed nodes
 549      * @param changes he dataChange object
 550      * @param klazz The class type
 551      * @return A set to removed nodes as DataObject casted as the class type
 552      */
 553     public static <T extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
 554             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
 555         Set<InstanceIdentifier<T>> result = new HashSet<InstanceIdentifier<T>>();
 556         if (changes != null && changes.getRemovedPaths() != null) {
 557             for (InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
 558                 if (iid.getTargetType().equals(klazz)) {
 559                     @SuppressWarnings("unchecked") // Actually checked above
 560                     InstanceIdentifier<T> iidn = (InstanceIdentifier<T>)iid;
 561                     result.add(iidn);
 562                 }
 563             }
 564         }
 565         return result;
 566     }
 567
 568     /**
 569      * Search the Operational Datastore for a specific OvsdbNode.
 570      * @param dataBroker The dataBroker instance to create transactions
 571      * @param uni The UNI's data
 572      * @return The Optional OvsdbNode
 573      */
 574     public static Optional<Node> findOvsdbNode(DataBroker dataBroker,
 575                                                UniAugmentation uni) {
 576         List<Node> ovsdbNodes = getOvsdbNodes(dataBroker);
 577         Optional<Node> optionalOvsdb;
 578         if (!ovsdbNodes.isEmpty()) {
 579             for (Node ovsdbNode : ovsdbNodes) {
 580                 OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
 581                                                                   .getAugmentation(OvsdbNodeAugmentation.class);
 582                 if (ovsdbNodeAugmentation.getConnectionInfo()
 583                                          .getRemoteIp()
 584                                          .getIpv4Address()
 585                         .equals(uni.getIpAddress().getIpv4Address())) {
 586                     LOG.info("Found ovsdb node");
 587                     optionalOvsdb = Optional.of(ovsdbNode);
 588                     return optionalOvsdb;
 589                 }
 590             }
 591         }
 592         return Optional.absent();
 593     }
 594
 595     /**
 596      * Search the Operation DataStore for a specific UNI
 597      * @param dataBroker The dataBroker instance to create transactions
 598      * @param ipAddress The IP address of the UNI
 599      * @return An Optional UNI Node
 600      */
 601     public static Optional<Node> findUniNode(DataBroker dataBroker,
 602                                              IpAddress ipAddress) {
 603         List<Node> uniNodes = getUniNodes(dataBroker);
 604         if (!uniNodes.isEmpty()) {
 605             for (Node uniNode : uniNodes) {
 606                 UniAugmentation uniAugmentation = uniNode.getAugmentation(UniAugmentation.class);
 607                 if (uniAugmentation.getIpAddress().equals(ipAddress)) {
 608                     LOG.info("Found Uni node");
 609                     return Optional.of(uniNode);
 610                 }
 611             }
 612         }
 613         return Optional.absent();
 614     }
 615
 616     /**
 617      * Retrieves the connection information from an Ovsdb Connection by
 618      * using the Ovsdb Node Id
 619      * @param dataBroker The dataBroker instance to create transactions
 620      * @param ovsdbNodeId The NodeId of the OVSDB node
 621      * @return The ConnectionInfo object
 622      */
 623     public static ConnectionInfo getConnectionInfo(DataBroker dataBroker,
 624                                                    NodeId ovsdbNodeId) {
 625         InstanceIdentifier<Node> nodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNodeId);
 626         Optional<Node> node = readNode(dataBroker,
 627                                        LogicalDatastoreType.OPERATIONAL,
 628                                        nodeIid);
 629         if (node.isPresent()) {
 630             Node ovsdbNode = node.get();
 631             OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
 632                                                               .getAugmentation(OvsdbNodeAugmentation.class);
 633             ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
 634             return connectionInfo;
 635         } else {
 636             return null;
 637         }
 638     }
 639
 640     /**
 641      * Retrieve the list of links in the Operational DataStore
 642      * @param dataBroker The dataBroker instance to create transactions
 643      * @return A list of Links retrieved from the Operational DataStore
 644      */
 645     public static List<Link> getEvcLinks(DataBroker dataBroker) {
 646         List<Link> evcLinks = new ArrayList<>();
 647         InstanceIdentifier<Topology> evcTopology = UnimgrMapper.getEvcTopologyIid();
 648         Topology topology = UnimgrUtils.read(dataBroker,
 649                                              LogicalDatastoreType.OPERATIONAL,
 650                                              evcTopology);
 651         if (topology != null && topology.getLink() != null) {
 652             for (Link link : topology.getLink()) {
 653                 EvcAugmentation evcAugmentation = link.getAugmentation(EvcAugmentation.class);
 654                 if (evcAugmentation != null) {
 655                     evcLinks.add(link);
 656                 }
 657             }
 658         }
 659         return evcLinks;
 660     }
 661
 662     /**
 663      * Retrieve the Local IP of the controller
 664      * @return The LocalIp object of the Controller
 665      */
 666     public static IpAddress getLocalIp() {
 667         String ip;
 668         try {
 669             ip = InetAddress.getLocalHost().getHostAddress();
 670             Ipv4Address ipv4 = new Ipv4Address(ip);
 671             IpAddress ipAddress = new IpAddress(ipv4);
 672             return ipAddress;
 673         } catch (UnknownHostException e) {
 674             LOG.info("Unable to retrieve controller's ip address, using loopback.");
 675         }
 676         return new IpAddress(UnimgrConstants.LOCAL_IP);
 677     }
 678
 679     /**
 680      * Retrieve a list of Ovsdb Nodes from the Operational DataStore
 681      * @param dataBroker The dataBroker instance to create transactions
 682      * @return The Ovsdb Node retrieved from the Operational DataStore
 683      */
 684     public static List<Node> getOvsdbNodes(DataBroker dataBroker) {
 685         List<Node> ovsdbNodes = new ArrayList<>();
 686         InstanceIdentifier<Topology> ovsdbTopoIdentifier = UnimgrMapper.getOvsdbTopologyIid();
 687         Topology topology = UnimgrUtils.read(dataBroker,
 688                                              LogicalDatastoreType.OPERATIONAL,
 689                                              ovsdbTopoIdentifier);
 690         if (topology != null && topology.getNode() != null) {
 691             for (Node node : topology.getNode()) {
 692                 OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
 693                 if (ovsdbNodeAugmentation != null) {
 694                     ovsdbNodes.add(node);
 695                 }
 696             }
 697         }
 698         return ovsdbNodes;
 699     }
 700
 701     /**
 702      * Retrieve a list of Uni Nodes from the Configuration DataStore
 703      * @param dataBroker The dataBroker instance to create transactions
 704      * @return A list of Uni Nodes from the Config dataStore
 705      */
 706     public static List<Node> getUniNodes(DataBroker dataBroker) {
 707         List<Node> uniNodes = new ArrayList<>();
 708         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
 709         Topology topology = read(dataBroker,
 710                                  LogicalDatastoreType.CONFIGURATION,
 711                                  topologyInstanceIdentifier);
 712         if (topology != null && topology.getNode() != null) {
 713             for (Node node : topology.getNode()) {
 714                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 715                 if (uniAugmentation != null) {
 716                     uniNodes.add(node);
 717                 }
 718             }
 719         }
 720         return uniNodes;
 721     }
 722
 723     /**
 724      * Retrieve a list of Uni Nodes on a specific DataStore
 725      * @param dataBroker The dataBroker instance to create transactions
 726      * @param store The store to which to send the read request
 727      * @return A List of UNI Nodes.
 728      */
 729     public static List<Node> getUniNodes(DataBroker dataBroker,
 730                                          LogicalDatastoreType store) {
 731         List<Node> uniNodes = new ArrayList<>();
 732         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
 733         Topology topology = read(dataBroker,
 734                                  store,
 735                                  topologyInstanceIdentifier);
 736         if (topology != null && topology.getNode() != null) {
 737             for (Node node : topology.getNode()) {
 738                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 739                 if (uniAugmentation != null) {
 740                     uniNodes.add(node);
 741                 }
 742             }
 743         }
 744         return uniNodes;
 745     }
 746
 747     /**
 748      * Retrieve a list of Unis on a specific DataStore
 749      * @param dataBroker instance to create transactions
 750      * @param store to which send the read request
 751      * @return A List of Unis.
 752      */
 753     public static List<UniAugmentation> getUnis(DataBroker dataBroker,
 754                                          LogicalDatastoreType store) {
 755         List<UniAugmentation> unis = new ArrayList<>();
 756         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
 757         Topology topology = read(dataBroker,
 758                                  store,
 759                                  topologyInstanceIdentifier);
 760         if (topology != null && topology.getNode() != null) {
 761             for (Node node : topology.getNode()) {
 762                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 763                 if (uniAugmentation != null) {
 764                     unis.add(uniAugmentation);
 765                 }
 766             }
 767         }
 768         return unis;
 769     }
 770
 771     /**
 772      * Retrieve a list of Unis on a specific DataStore
 773      * @param dataBroker instance to create transactions
 774      * @param store to which send the read request
 775      * @param ipAddress of the required Uni
 776      * @return uni.
 777      */
 778     public static UniAugmentation getUni(DataBroker dataBroker,
 779                                          LogicalDatastoreType store, IpAddress ipAddress) {
 780         InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
 781         Topology topology = read(dataBroker,
 782                                  store,
 783                                  topologyInstanceIdentifier);
 784         if (topology != null && topology.getNode() != null) {
 785             for (Node node : topology.getNode()) {
 786                 UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
 787                 if (uniAugmentation != null && uniAugmentation.getIpAddress().getIpv4Address().getValue().equals(ipAddress.getIpv4Address().getValue())) {
 788                     return uniAugmentation;
 789                 }
 790             }
 791         }
 792         return null;
 793     }
 794
 795     /**
 796      * Read a specific datastore type and return a DataObject as a casted
 797      * class type Object.
 798      * @param dataBroker The dataBroker instance to create transactions
 799      * @param store The store type to query
 800      * @param path The generic path to query
 801      * @return The DataObject as a casted Object
 802      */
 803     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
 804             DataBroker dataBroker,
 805             final LogicalDatastoreType store,
 806             final InstanceIdentifier<D> path)  {
 807         D result = null;
 808         final ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
 809         Optional<D> optionalDataObject;
 810         CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
 811         try {
 812             optionalDataObject = future.checkedGet();
 813             if (optionalDataObject.isPresent()) {
 814                 result = optionalDataObject.get();
 815             } else {
 816                 LOG.debug("{}: Failed to read {}",
 817                         Thread.currentThread().getStackTrace()[1], path);
 818             }
 819         } catch (ReadFailedException e) {
 820             LOG.warn("Failed to read {} ", path, e);
 821         }
 822         transaction.close();
 823         return result;
 824     }
 825
 826     /**
 827      * Read a specific node from the Operational Data store by default.
 828      * @param dataBroker The dataBroker instance to create transactions
 829      * @param genericNode The Instance Identifier of the Node
 830      * @return The Optional Node instance
 831      */
 832     @Deprecated
 833     public static final Optional<Node> readNode(DataBroker dataBroker,
 834                                                 InstanceIdentifier<?> genericNode) {
 835         ReadTransaction read = dataBroker.newReadOnlyTransaction();
 836         InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
 837         CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
 838                                                               read.read(LogicalDatastoreType.OPERATIONAL,
 839                                                                         nodeIid);
 840         try {
 841             return nodeFuture.checkedGet();
 842         } catch (ReadFailedException e) {
 843             LOG.info("Unable to read node with Iid {}", nodeIid);
 844         }
 845         return Optional.absent();
 846     }
 847
 848     /**
 849      * Read a specific Link from a specific datastore
 850      * @param dataBroker The dataBroker instance to create transactions
 851      * @param store The datastore type.
 852      * @param genericNode The Instance Identifier of the Link
 853      * @return An Optional Link instance
 854      */
 855     public static final Optional<Link> readLink(DataBroker dataBroker,
 856                                                 LogicalDatastoreType store,
 857                                                 InstanceIdentifier<?> genericNode) {
 858         ReadTransaction read = dataBroker.newReadOnlyTransaction();
 859         InstanceIdentifier<Link> linkIid = genericNode.firstIdentifierOf(Link.class);
 860         CheckedFuture<Optional<Link>, ReadFailedException> linkFuture = read.read(store, linkIid);
 861         try {
 862             return linkFuture.checkedGet();
 863         } catch (ReadFailedException e) {
 864             LOG.info("Unable to read node with Iid {}", linkIid);
 865         }
 866         return Optional.absent();
 867     }
 868
 869     /**
 870      * Read a specific node from a specific data store type.
 871      * @param dataBroker The dataBroker instance to create transactions
 872      * @param store The data store type
 873      * @param genericNode The Instance Identifier of a specific Node
 874      * @return An Optional Node instance
 875      */
 876     public static final Optional<Node> readNode(DataBroker dataBroker,
 877                                                 LogicalDatastoreType store,
 878                                                 InstanceIdentifier<?> genericNode) {
 879         ReadTransaction read = dataBroker.newReadOnlyTransaction();
 880         InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
 881         CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = read
 882                 .read(store, nodeIid);
 883         try {
 884             return nodeFuture.checkedGet();
 885         } catch (ReadFailedException e) {
 886             LOG.info("Unable to read node with Iid {}", nodeIid);
 887         }
 888         return Optional.absent();
 889     }
 890
 891     /**
 892      * Updates a specific Uni Node on a specific DataStore type
 893      * @param dataStore The datastore type
 894      * @param uniKey The UNI key
 895      * @param uni The Uni's data
 896      * @param ovsdbNode The Ovsdb Node
 897      * @param dataBroker The dataBroker instance to create transactions
 898      */
 899     public static void updateUniNode(LogicalDatastoreType dataStore,
 900                                      InstanceIdentifier<?> uniKey,
 901                                      UniAugmentation uni,
 902                                      Node ovsdbNode,
 903                                      DataBroker dataBroker) {
 904         InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNode.getNodeId());
 905         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 906         UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
 907         if (ovsdbNodeRef != null) {
 908             updatedUniBuilder.setOvsdbNodeRef(ovsdbNodeRef);
 909         }
 910         Optional<Node> optionalNode = readNode(dataBroker,
 911                                                LogicalDatastoreType.CONFIGURATION,
 912                                                uniKey);
 913         if (optionalNode.isPresent()) {
 914             Node node = optionalNode.get();
 915             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 916             NodeBuilder nodeBuilder = new NodeBuilder();
 917             nodeBuilder.setKey(node.getKey());
 918             nodeBuilder.setNodeId(node.getNodeId());
 919             nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
 920             transaction.put(dataStore, uniKey.firstIdentifierOf(Node.class), nodeBuilder.build());
 921             transaction.submit();
 922         }
 923     }
 924
 925     /**
 926      * Update a specific UNI node on a specific datastore type
 927      * @param dataStore The datastore type
 928      * @param uniKey The UNI key
 929      * @param uni The Uni's data
 930      * @param ovsdbNodeIid The Ovsdb Node Instance Identifier
 931      * @param dataBroker The dataBroker instance to create transactions
 932      */
 933     public static void updateUniNode(LogicalDatastoreType dataStore,
 934                                      InstanceIdentifier<?> uniKey,
 935                                      UniAugmentation uni,
 936                                      InstanceIdentifier<?> ovsdbNodeIid,
 937                                      DataBroker dataBroker) {
 938         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
 939         UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
 940         if (ovsdbNodeRef != null) {
 941             updatedUniBuilder.setOvsdbNodeRef(ovsdbNodeRef);
 942         }
 943         Optional<Node> optionalNode = readNode(dataBroker,
 944                                                LogicalDatastoreType.CONFIGURATION,
 945                                                uniKey);
 946         if (optionalNode.isPresent()) {
 947             Node node = optionalNode.get();
 948             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 949             NodeBuilder nodeBuilder = new NodeBuilder();
 950             nodeBuilder.setKey(node.getKey());
 951             nodeBuilder.setNodeId(node.getNodeId());
 952             nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
 953             transaction.put(dataStore, uniKey.firstIdentifierOf(Node.class), nodeBuilder.build());
 954             transaction.submit();
 955         }
 956     }
 957
 958     /**
 959      * Updates a specific EVC into a specific DataStore type
 960      * @param dataStore The datastore type
 961      * @param evcKey The EVC key
 962      * @param evcAugmentation The EVC's data
 963      * @param sourceUniIid The Source Uni Instance Identifier
 964      * @param destinationUniIid The destination Uni Instance Identifier
 965      * @param dataBroker The dataBroker instance to create transactions
 966      */
 967     public static void updateEvcNode(LogicalDatastoreType dataStore,
 968                                      InstanceIdentifier<?> evcKey,
 969                                      EvcAugmentation evcAugmentation,
 970                                      InstanceIdentifier<?> sourceUniIid,
 971                                      InstanceIdentifier<?> destinationUniIid,
 972                                      DataBroker dataBroker) {
 973         EvcAugmentationBuilder updatedEvcBuilder = new EvcAugmentationBuilder(evcAugmentation);
 974         if (sourceUniIid != null && destinationUniIid != null) {
 975             List<UniSource> sourceList = new ArrayList<UniSource>();
 976             UniSourceKey sourceKey = evcAugmentation.getUniSource().iterator().next().getKey();
 977             short sourceOrder = evcAugmentation.getUniSource().iterator().next().getOrder();
 978             IpAddress sourceIp = evcAugmentation.getUniSource().iterator().next().getIpAddress();
 979             UniSource uniSource = new UniSourceBuilder()
 980                                           .setOrder(sourceOrder)
 981                                           .setKey(sourceKey)
 982                                           .setIpAddress(sourceIp)
 983                                           .setUni(sourceUniIid)
 984                                           .build();
 985             sourceList.add(uniSource);
 986             updatedEvcBuilder.setUniSource(sourceList);
 987
 988             List<UniDest> destinationList = new ArrayList<UniDest>();
 989             UniDestKey destKey = evcAugmentation.getUniDest().iterator().next().getKey();
 990             short destOrder = evcAugmentation.getUniDest().iterator().next().getOrder();
 991             IpAddress destIp = evcAugmentation.getUniDest().iterator().next().getIpAddress();
 992             UniDest uniDest = new UniDestBuilder()
 993                                       .setIpAddress(destIp)
 994                                       .setOrder(destOrder)
 995                                       .setKey(destKey)
 996                                       .setUni(destinationUniIid)
 997                                       .build();
 998             destinationList.add(uniDest);
 999             updatedEvcBuilder.setUniDest(destinationList);
1000             Optional<Link> optionalEvcLink = readLink(dataBroker,
1001                                                       LogicalDatastoreType.CONFIGURATION,
1002                                                       evcKey);
1003             if (optionalEvcLink.isPresent()) {
1004                 Link link = optionalEvcLink.get();
1005                 WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
1006                 LinkBuilder linkBuilder = new LinkBuilder();
1007                 linkBuilder.setKey(link.getKey());
1008                 linkBuilder.setLinkId(link.getLinkId());
1009                 linkBuilder.addAugmentation(EvcAugmentation.class, updatedEvcBuilder.build());
1010                 transaction.put(dataStore, evcKey.firstIdentifierOf(Link.class), linkBuilder.build());
1011                 transaction.submit();
1012             }
1013         } else {
1014             LOG.info("Invalid instance identifiers for sourceUni and destUni.");
1015         }
1016     }
1017 }