interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/OvsdbSouthboundTestUtil.java

   1 /*
   2  * Copyright (c) 2015, 2017 Red Hat, Inc. 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
   9 package org.opendaylight.genius.interfacemanager.test;
  10
  11 import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
  12
  13 import com.google.common.collect.ImmutableBiMap;
  14 import java.net.Inet4Address;
  15 import java.net.Inet6Address;
  16 import java.net.InetAddress;
  17 import java.net.UnknownHostException;
  18 import java.util.ArrayList;
  19 import java.util.Arrays;
  20 import java.util.List;
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  24 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdk;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkr;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkvhost;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkvhostuser;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGeneve;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGre;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGre64;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeIpsecGre;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeIpsecGre64;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeLisp;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypePatch;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeSystem;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeTap;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlanGpe;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  64 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  74 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  75 import org.slf4j.Logger;
  76 import org.slf4j.LoggerFactory;
  77
  78 public class OvsdbSouthboundTestUtil {
  79     private static final Logger LOG = LoggerFactory.getLogger(OvsdbSouthboundTestUtil.class);
  80     private static final int OVSDB_UPDATE_TIMEOUT = 1000;
  81     public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
  82     public static final String OVSDB_URI_PREFIX = "ovsdb";
  83     public static final String BRIDGE_URI_PREFIX = "bridge";
  84
  85     public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>>
  86         OVSDB_INTERFACE_TYPE_MAP = new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
  87             .put("internal", InterfaceTypeInternal.class).put("vxlan", InterfaceTypeVxlan.class)
  88             .put("vxlan-gpe", InterfaceTypeVxlanGpe.class).put("patch", InterfaceTypePatch.class)
  89             .put("system", InterfaceTypeSystem.class).put("tap", InterfaceTypeTap.class)
  90             .put("geneve", InterfaceTypeGeneve.class).put("gre", InterfaceTypeGre.class)
  91             .put("ipsec_gre", InterfaceTypeIpsecGre.class).put("gre64", InterfaceTypeGre64.class)
  92             .put("ipsec_gre64", InterfaceTypeIpsecGre64.class).put("lisp", InterfaceTypeLisp.class)
  93             .put("dpdk", InterfaceTypeDpdk.class).put("dpdkr", InterfaceTypeDpdkr.class)
  94             .put("dpdkvhost", InterfaceTypeDpdkvhost.class).put("dpdkvhostuser", InterfaceTypeDpdkvhostuser.class)
  95             .build();
  96
  97     public static NodeId createNodeId(String ip, Integer port) {
  98         String uriString = OVSDB_URI_PREFIX + "://" + ip + ":" + port;
  99         Uri uri = new Uri(uriString);
 100         return new NodeId(uri);
 101     }
 102
 103     public static void createBridge(DataBroker dataBroker) throws TransactionCommitFailedException {
 104         final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
 105         final InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
 106         final InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = bridgeIid.builder()
 107                 .augmentation(OvsdbBridgeAugmentation.class).build();
 108         final NodeId bridgeNodeId = createManagedNodeId(bridgeIid);
 109         final NodeBuilder bridgeCreateNodeBuilder = new NodeBuilder();
 110         bridgeCreateNodeBuilder.setNodeId(bridgeNodeId);
 111         OvsdbBridgeAugmentationBuilder bridgeCreateAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 112         bridgeCreateAugmentationBuilder.setBridgeName(ovsdbBridgeName)
 113                 .setDatapathId(new DatapathId("00:00:00:00:00:00:00:01"));
 114         bridgeCreateNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, bridgeCreateAugmentationBuilder.build());
 115         LOG.debug("Built with the intent to store bridge data {}", bridgeCreateAugmentationBuilder.toString());
 116         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 117         tx.put(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, bridgeCreateAugmentationBuilder.build(), true);
 118         tx.submit().checkedGet();
 119     }
 120
 121     public static void updateBridge(DataBroker dataBroker, String datapathId) throws TransactionCommitFailedException {
 122         final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
 123         final InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
 124         final InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = bridgeIid.builder()
 125             .augmentation(OvsdbBridgeAugmentation.class).build();
 126         final NodeId bridgeNodeId = createManagedNodeId(bridgeIid);
 127         final NodeBuilder bridgeCreateNodeBuilder = new NodeBuilder();
 128         bridgeCreateNodeBuilder.setNodeId(bridgeNodeId);
 129         OvsdbBridgeAugmentationBuilder bridgeCreateAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 130         bridgeCreateAugmentationBuilder.setBridgeName(ovsdbBridgeName)
 131             .setDatapathId(new DatapathId(datapathId));
 132         bridgeCreateNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, bridgeCreateAugmentationBuilder.build());
 133         LOG.debug("Built with the intent to store bridge data {}", bridgeCreateAugmentationBuilder.toString());
 134         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 135         tx.merge(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid, bridgeCreateAugmentationBuilder.build(), true);
 136         tx.submit().checkedGet();
 137     }
 138
 139     public boolean deleteBridge(final ConnectionInfo connectionInfo, final String bridgeName) {
 140         return deleteBridge(connectionInfo, bridgeName, OVSDB_UPDATE_TIMEOUT);
 141     }
 142
 143     public boolean deleteBridge(final ConnectionInfo connectionInfo, final String bridgeName, long timeout) {
 144         boolean result = true;
 145         // mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 146         // createInstanceIdentifier(connectionInfo, new
 147         // OvsdbBridgeName(bridgeName)));
 148         if (timeout != 0) {
 149             try {
 150                 Thread.sleep(timeout);
 151             } catch (InterruptedException e) {
 152                 LOG.warn("Interrupted while waiting after deleting bridge {}", bridgeName, e);
 153             }
 154         }
 155         return result;
 156     }
 157
 158     public static void deleteBridge(DataBroker dataBroker) {
 159         final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
 160         final InstanceIdentifier<Node> bridgeIid = createInstanceIdentifier("192.168.56.101", 6640, ovsdbBridgeName);
 161         final InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = bridgeIid.builder()
 162                 .augmentation(OvsdbBridgeAugmentation.class).build();
 163         LOG.debug("Built with the intent to delete bridge data {}", bridgeIid.toString());
 164         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 165         tx.delete(LogicalDatastoreType.OPERATIONAL, ovsdbBridgeIid);
 166         tx.submit();
 167
 168     }
 169
 170     public static InstanceIdentifier<Node> createInstanceIdentifier(NodeId nodeId) {
 171         return InstanceIdentifier.create(NetworkTopology.class)
 172                 .child(Topology.class, new TopologyKey(OVSDB_TOPOLOGY_ID)).child(Node.class, new NodeKey(nodeId));
 173     }
 174
 175     public static InstanceIdentifier<Node> createInstanceIdentifier(String ip, Integer port) {
 176         InstanceIdentifier<Node> path = InstanceIdentifier.create(NetworkTopology.class)
 177                 .child(Topology.class, new TopologyKey(OVSDB_TOPOLOGY_ID)).child(Node.class, createNodeKey(ip, port));
 178         LOG.debug("Created ovsdb path: {}", path);
 179         return path;
 180     }
 181
 182     public static InstanceIdentifier<Node> createInstanceIdentifier(String remoteIp, Integer remotePort,
 183             OvsdbBridgeName bridgeName) {
 184         return createInstanceIdentifier(createManagedNodeId(remoteIp, remotePort, bridgeName));
 185     }
 186
 187     public static InstanceIdentifier<Node> createInstanceIdentifier(NodeKey ovsdbNodeKey, String bridgeName) {
 188         return createInstanceIdentifier(createManagedNodeId(ovsdbNodeKey.getNodeId(), bridgeName));
 189     }
 190
 191     public static InstanceIdentifier<Node> createInstanceIdentifier(String ip, Integer port, String bridgeName) {
 192         return createInstanceIdentifier(ip, port, new OvsdbBridgeName(bridgeName));
 193     }
 194
 195     public static NodeId createManagedNodeId(String ip, Integer port, OvsdbBridgeName bridgeName) {
 196         return new NodeId(createNodeId(ip, port).getValue() + "/" + BRIDGE_URI_PREFIX + "/" + bridgeName.getValue());
 197     }
 198
 199     public static NodeId createManagedNodeId(InstanceIdentifier<Node> iid) {
 200         NodeKey nodeKey = iid.firstKeyOf(Node.class);
 201         return nodeKey.getNodeId();
 202     }
 203
 204     public static NodeId createManagedNodeId(NodeId ovsdbNodeId, String bridgeName) {
 205         return new NodeId(ovsdbNodeId.getValue() + "/" + BRIDGE_URI_PREFIX + "/" + bridgeName);
 206     }
 207
 208     public static InstanceIdentifier<TerminationPoint> createTerminationPointInstanceIdentifier(NodeKey nodeKey, String
 209         portName) {
 210         InstanceIdentifier<TerminationPoint> terminationPointPath = InstanceIdentifier
 211                 .create(NetworkTopology.class)
 212                 .child(Topology.class, new TopologyKey(OVSDB_TOPOLOGY_ID))
 213                 .child(Node.class,nodeKey)
 214                 .child(TerminationPoint.class, new TerminationPointKey(new TpId(portName)));
 215
 216         LOG.debug("Termination point InstanceIdentifier generated : {}", terminationPointPath);
 217         return terminationPointPath;
 218     }
 219
 220     public static void createTerminationPoint(DataBroker dataBroker, String interfaceName,
 221                                               Class<? extends InterfaceTypeBase> type, String externalId) throws
 222         TransactionCommitFailedException {
 223         final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
 224         final InstanceIdentifier<Node> bridgeIid =
 225             createInstanceIdentifier("192.168.56.101", 6640,  ovsdbBridgeName);
 226         InstanceIdentifier<TerminationPoint> tpId = createTerminationPointInstanceIdentifier(
 227                 InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), interfaceName);
 228         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 229         tpBuilder.setKey(InstanceIdentifier.keyOf(tpId));
 230         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 231
 232         tpAugmentationBuilder.setName(interfaceName);
 233         if (type != null) {
 234             tpAugmentationBuilder.setInterfaceType(type);
 235         }
 236         if (externalId != null) {
 237             List<InterfaceExternalIds> interfaceExternalIds = new ArrayList<>();
 238             InterfaceExternalIds interfaceExternalIds1 = new InterfaceExternalIdsBuilder().setExternalIdKey("iface-id")
 239                 .setExternalIdValue(externalId).build();
 240             interfaceExternalIds.add(interfaceExternalIds1);
 241             tpAugmentationBuilder.setInterfaceExternalIds(interfaceExternalIds);
 242         }
 243         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 244         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 245         tx.put(OPERATIONAL, tpId, tpBuilder.build(), true);
 246         tx.submit().checkedGet();
 247     }
 248
 249     public static void updateTerminationPoint(DataBroker dataBroker, String interfaceName,
 250                                               Class<? extends InterfaceTypeBase> type) throws
 251         TransactionCommitFailedException {
 252         final OvsdbBridgeName ovsdbBridgeName = new OvsdbBridgeName("s2");
 253         final InstanceIdentifier<Node> bridgeIid =
 254             createInstanceIdentifier("192.168.56.101", 6640,  ovsdbBridgeName);
 255         InstanceIdentifier<TerminationPoint> tpId = createTerminationPointInstanceIdentifier(
 256             InstanceIdentifier.keyOf(bridgeIid.firstIdentifierOf(Node.class)), interfaceName);
 257         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 258         tpBuilder.setKey(InstanceIdentifier.keyOf(tpId));
 259         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = new OvsdbTerminationPointAugmentationBuilder();
 260
 261         tpAugmentationBuilder.setName(interfaceName);
 262         if (type != null) {
 263             tpAugmentationBuilder.setInterfaceType(type);
 264         }
 265         List<InterfaceBfdStatus> interfaceBfdStatuses = Arrays.asList(new InterfaceBfdStatusBuilder()
 266             .setBfdStatusKey("state").setBfdStatusValue("down").build());
 267
 268         tpAugmentationBuilder.setInterfaceBfdStatus(interfaceBfdStatuses);
 269         tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
 270         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 271         tx.merge(OPERATIONAL, tpId, tpBuilder.build(), true);
 272         tx.submit().checkedGet();
 273     }
 274
 275     public static NodeKey createNodeKey(String ip, Integer port) {
 276         return new NodeKey(createNodeId(ip, port));
 277     }
 278
 279     public static ConnectionInfo getConnectionInfo(final String addressStr, final String portStr) {
 280         InetAddress inetAddress = null;
 281         try {
 282             inetAddress = InetAddress.getByName(addressStr);
 283         } catch (UnknownHostException e) {
 284             LOG.warn("Could not allocate InetAddress", e);
 285         }
 286
 287         IpAddress address = createIpAddress(inetAddress);
 288         PortNumber port = new PortNumber(Integer.parseInt(portStr));
 289
 290         LOG.info("connectionInfo: {}", new ConnectionInfoBuilder().setRemoteIp(address).setRemotePort(port).build());
 291         return new ConnectionInfoBuilder().setRemoteIp(address).setRemotePort(port).build();
 292     }
 293
 294     public ConnectionInfo getConnectionInfo(Node ovsdbNode) {
 295         ConnectionInfo connectionInfo = null;
 296         OvsdbNodeAugmentation ovsdbNodeAugmentation = extractOvsdbNode(ovsdbNode);
 297         if (ovsdbNodeAugmentation != null) {
 298             connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
 299         }
 300         return connectionInfo;
 301     }
 302
 303     public OvsdbNodeAugmentation extractOvsdbNode(Node node) {
 304         return node.getAugmentation(OvsdbNodeAugmentation.class);
 305     }
 306
 307     public static IpAddress createIpAddress(InetAddress address) {
 308         IpAddress ip = null;
 309         if (address instanceof Inet4Address) {
 310             ip = createIpAddress((Inet4Address) address);
 311         } else if (address instanceof Inet6Address) {
 312             ip = createIpAddress((Inet6Address) address);
 313         }
 314         return ip;
 315     }
 316
 317     public static IpAddress createIpAddress(Inet4Address address) {
 318         return IetfInetUtil.INSTANCE.ipAddressFor(address);
 319     }
 320
 321     public static IpAddress createIpAddress(Inet6Address address) {
 322         Ipv6Address ipv6 = new Ipv6Address(address.getHostAddress());
 323         return new IpAddress(ipv6);
 324     }
 325
 326     public static String connectionInfoToString(final ConnectionInfo connectionInfo) {
 327         return String.valueOf(connectionInfo.getRemoteIp().getValue()) + ":"
 328                 + connectionInfo.getRemotePort().getValue();
 329     }
 330
 331     public boolean addOvsdbNode(final ConnectionInfo connectionInfo) {
 332         return addOvsdbNode(connectionInfo, OVSDB_UPDATE_TIMEOUT);
 333     }
 334
 335     public boolean addOvsdbNode(final ConnectionInfo connectionInfo, long timeout) {
 336         boolean result = true;
 337         // mdsalUtils.put(LogicalDatastoreType.CONFIGURATION,
 338         // createInstanceIdentifier(connectionInfo),
 339         // createNode(connectionInfo));
 340         if (timeout != 0) {
 341             try {
 342                 Thread.sleep(timeout);
 343             } catch (InterruptedException e) {
 344                 LOG.warn("Interrupted while waiting after adding OVSDB node {}", connectionInfoToString(connectionInfo),
 345                         e);
 346             }
 347         }
 348         return result;
 349     }
 350
 351     public Node getOvsdbNode(final ConnectionInfo connectionInfo) {
 352         // return mdsalUtils.read(LogicalDatastoreType.OPERATIONAL,
 353         // createInstanceIdentifier(connectionInfo));
 354         return null;
 355     }
 356
 357     public boolean deleteOvsdbNode(final ConnectionInfo connectionInfo) {
 358         return deleteOvsdbNode(connectionInfo, OVSDB_UPDATE_TIMEOUT);
 359     }
 360
 361     public boolean deleteOvsdbNode(final ConnectionInfo connectionInfo, long timeout) {
 362         boolean result = true;
 363         // mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION,
 364         // createInstanceIdentifier(connectionInfo));
 365         if (timeout != 0) {
 366             try {
 367                 Thread.sleep(timeout);
 368             } catch (InterruptedException e) {
 369                 LOG.warn("Interrupted while waiting after deleting OVSDB node {}",
 370                         connectionInfoToString(connectionInfo), e);
 371             }
 372         }
 373         return result;
 374     }
 375
 376     public Node connectOvsdbNode(final ConnectionInfo connectionInfo) {
 377         return connectOvsdbNode(connectionInfo, OVSDB_UPDATE_TIMEOUT);
 378     }
 379
 380     public Node connectOvsdbNode(final ConnectionInfo connectionInfo, long timeout) {
 381         addOvsdbNode(connectionInfo, timeout);
 382         Node node = getOvsdbNode(connectionInfo);
 383         LOG.info("Connected to {}", connectionInfoToString(connectionInfo));
 384         return node;
 385     }
 386
 387     public boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo) {
 388         return disconnectOvsdbNode(connectionInfo, OVSDB_UPDATE_TIMEOUT);
 389     }
 390
 391     public boolean disconnectOvsdbNode(final ConnectionInfo connectionInfo, long timeout) {
 392         deleteOvsdbNode(connectionInfo, timeout);
 393         LOG.info("Disconnected from {}", connectionInfoToString(connectionInfo));
 394         return true;
 395     }
 396
 397     public List<ControllerEntry> createControllerEntry(String controllerTarget) {
 398         List<ControllerEntry> controllerEntriesList = new ArrayList<>();
 399         controllerEntriesList.add(new ControllerEntryBuilder().setTarget(new Uri(controllerTarget)).build());
 400         return controllerEntriesList;
 401     }
 402
 403     public OvsdbNodeAugmentation extractNodeAugmentation(Node node) {
 404         return node.getAugmentation(OvsdbNodeAugmentation.class);
 405     }
 406
 407     public OvsdbBridgeAugmentation extractBridgeAugmentation(Node node) {
 408         if (node == null) {
 409             return null;
 410         }
 411         return node.getAugmentation(OvsdbBridgeAugmentation.class);
 412     }
 413 }