X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=southbound%2Fsouthbound-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fovsdb%2Fsouthbound%2FSouthboundUtil.java;h=378ac16d8a6ff6b2ca4c8e9d3b1bd1c5e1281e00;hb=48096e085b70127b9358d9ec33e772a6d94f569d;hp=3e2ecb9743844d0978e2789dd7d6e969a2f3aa32;hpb=53770e68e6b68362ae957260d25d07023781f03a;p=ovsdb.git diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/SouthboundUtil.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/SouthboundUtil.java index 3e2ecb974..378ac16d8 100644 --- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/SouthboundUtil.java +++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/SouthboundUtil.java @@ -7,66 +7,56 @@ */ package org.opendaylight.ovsdb.southbound; -import com.google.common.base.Optional; +import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FluentFuture; import java.net.InetAddress; import java.net.NetworkInterface; +import java.net.SocketException; import java.util.Enumeration; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import java.util.Optional; +import java.util.concurrent.ExecutionException; + +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.binding.api.ReadWriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAttributes; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; +import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class SouthboundUtil { +public final class SouthboundUtil { private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtil.class); - - private static InstanceIdentifierCodec instanceIdentifierCodec; + private static final String SCHEMA_VERSION_MISMATCH = + "{} column for {} table is not supported by this version of the {} schema: {}"; private SouthboundUtil() { // Prevent instantiating a utility class } - public static void setInstanceIdentifierCodec(InstanceIdentifierCodec iidc) { - instanceIdentifierCodec = iidc; - } - - public static String serializeInstanceIdentifier(InstanceIdentifier iid) { - return instanceIdentifierCodec.serialize(iid); - } - - public static InstanceIdentifier deserializeInstanceIdentifier(String iidString) { - InstanceIdentifier result = null; - try { - result = instanceIdentifierCodec.bindingDeserializer(iidString); - } catch (DeserializationException e) { - LOG.warn("Unable to deserialize iidString", e); - } - return result; - } - - public static Optional getManagingNode(DataBroker db, OvsdbBridgeAttributes mn) { Preconditions.checkNotNull(mn); try { OvsdbNodeRef ref = mn.getManagedBy(); if (ref != null && ref.getValue() != null) { - ReadOnlyTransaction transaction = db.newReadOnlyTransaction(); - @SuppressWarnings("unchecked") // Note: erasure makes this safe in combination with the typecheck below + ReadTransaction transaction = db.newReadOnlyTransaction(); + @SuppressWarnings("unchecked") + // Note: erasure makes this safe in combination with the typecheck below InstanceIdentifier path = (InstanceIdentifier) ref.getValue(); - CheckedFuture, ReadFailedException> nf = transaction.read( + FluentFuture> nf = transaction.read( LogicalDatastoreType.OPERATIONAL, path); transaction.close(); Optional optional = nf.get(); @@ -76,56 +66,84 @@ public class SouthboundUtil { if (node instanceof OvsdbNodeAugmentation) { ovsdbNode = (OvsdbNodeAugmentation) node; } else if (node != null) { - ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class); + ovsdbNode = node.augmentation(OvsdbNodeAugmentation.class); } if (ovsdbNode != null) { return Optional.of(ovsdbNode); } else { LOG.warn("OvsdbManagedNode {} claims to be managed by {} but " + "that OvsdbNode does not exist", mn, ref.getValue()); - return Optional.absent(); + return Optional.empty(); } } else { LOG.warn("Mysteriously got back a thing which is *not* a topology Node: {}", optional); - return Optional.absent(); + return Optional.empty(); } } else { LOG.warn("Cannot find client for OvsdbManagedNode without a specified ManagedBy {}", mn); - return Optional.absent(); + return Optional.empty(); } - } catch (Exception e) { + } catch (InterruptedException | ExecutionException e) { LOG.warn("Failed to get OvsdbNode that manages OvsdbManagedNode {}", mn, e); - return Optional.absent(); + return Optional.empty(); } } - public static Optional readNode( - ReadWriteTransaction transaction, final InstanceIdentifier connectionIid) { - Optional node = Optional.absent(); + public static Optional readNode(ReadWriteTransaction transaction, + InstanceIdentifier connectionIid) { + Optional node; + try { + Node cachedNode = OvsdbOperGlobalListener.OPER_NODE_CACHE.get(connectionIid); + if (cachedNode != null) { + node = Optional.of((D)cachedNode); + } else { + node = transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid).get(); + } + } catch (InterruptedException | ExecutionException e) { + LOG.warn("Read Operational/DS for Node failed! {}", connectionIid, e); + throw new RuntimeException(e); + } + return node; + } + + public static Optional readNode(ReadTransaction transaction, + InstanceIdentifier connectionIid) { + Optional node; try { - node = transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid).checkedGet(); - } catch (final ReadFailedException e) { + Node cachedNode = OvsdbOperGlobalListener.OPER_NODE_CACHE.get(connectionIid); + if (cachedNode != null) { + node = Optional.of((D)cachedNode); + } else { + node = transaction.read(LogicalDatastoreType.OPERATIONAL, connectionIid).get(); + } + } catch (InterruptedException | ExecutionException e) { LOG.warn("Read Operational/DS for Node failed! {}", connectionIid, e); + throw new RuntimeException(e); } return node; } - private static String getLocalControllerHostIpAddress() { + @VisibleForTesting + static String getLocalControllerHostIpAddress() { String ipaddress = null; try { - for (Enumeration ifaces = NetworkInterface.getNetworkInterfaces(); - ifaces.hasMoreElements();) { - NetworkInterface iface = ifaces.nextElement(); - - for (Enumeration inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements();) { - InetAddress inetAddr = inetAddrs.nextElement(); - if (!inetAddr.isLoopbackAddress() && inetAddr.isSiteLocalAddress()) { - ipaddress = inetAddr.getHostAddress(); - break; + Enumeration ifaces = NetworkInterface.getNetworkInterfaces(); + if (ifaces != null) { + while (ifaces.hasMoreElements()) { + NetworkInterface iface = ifaces.nextElement(); + + for (Enumeration inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements();) { + InetAddress inetAddr = inetAddrs.nextElement(); + if (!inetAddr.isLoopbackAddress() && inetAddr.isSiteLocalAddress()) { + ipaddress = inetAddr.getHostAddress(); + break; + } } } + } else { + LOG.warn("Local Host don't have any associated IP address"); } - } catch (Exception e) { + } catch (SocketException e) { LOG.warn("Exception while fetching local host ip address ",e); } return ipaddress; @@ -134,11 +152,11 @@ public class SouthboundUtil { public static String getControllerTarget(Node ovsdbNode) { String target = null; String ipAddr = null; - OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class); + OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.augmentation(OvsdbNodeAugmentation.class); ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo(); LOG.info("connectionInfo: {}", connectionInfo); if (connectionInfo != null && connectionInfo.getLocalIp() != null) { - ipAddr = new String(connectionInfo.getLocalIp().getValue()); + ipAddr = connectionInfo.getLocalIp().stringValue(); } if (ipAddr == null) { ipAddr = getLocalControllerHostIpAddress(); @@ -151,4 +169,48 @@ public class SouthboundUtil { return target; } + + public static String connectionInfoToString(final ConnectionInfo connectionInfo) { + return connectionInfo.getRemoteIp().stringValue() + ":" + connectionInfo.getRemotePort().getValue(); + } + + public static void schemaMismatchLog(String column, String table, SchemaVersionMismatchException ex) { + LOG.debug(SCHEMA_VERSION_MISMATCH, column, table, SouthboundConstants.OPEN_V_SWITCH, ex.getMessage()); + } + + public static PortExternalIds createExternalIdsForPort(String key, String value) { + return new PortExternalIdsBuilder() + .setExternalIdKey(key) + .setExternalIdValue(value).build(); + } + + public static InterfaceExternalIds createExternalIdsForInterface(String key, String value) { + return new InterfaceExternalIdsBuilder() + .setExternalIdKey(key) + .setExternalIdValue(value).build(); + } + + @SuppressWarnings("checkstyle:IllegalCatch") + public static String getOvsdbNodeId(InstanceIdentifier nodeIid) { + String nodeId = ""; + if (nodeIid != null) { + try { + nodeId = nodeIid.toString(); + nodeId = nodeIid.firstKeyOf(Node.class).getNodeId().getValue(); + } catch (Exception exp) { + LOG.debug("Exception in getting the value from {} ", nodeIid); + } + } + return nodeId; + } + + public static String getBridgeNameFromOvsdbNodeId(InstanceIdentifier nodeIid) { + String nodeId = getOvsdbNodeId(nodeIid); + if (nodeId != null && !nodeId.isEmpty() && nodeId.contains("bridge") + && nodeId.lastIndexOf("bridge") + 7 < nodeId.length()) { + return nodeId.substring(nodeId.indexOf("bridge") + 7);// to fetch bridge name ex: "/bridge/br-int" + } else { + return null; + } + } }