Java tutorial
/* * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.genius.mdsalutil; import com.google.common.base.Optional; import com.google.common.net.InetAddresses; import com.google.common.primitives.Ints; import com.google.common.primitives.UnsignedBytes; import java.math.BigInteger; import java.net.Inet4Address; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.LinkedList; import java.util.List; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class NWUtil { private static final Logger LOG = LoggerFactory.getLogger(NWUtil.class); public static long convertInetAddressToLong(InetAddress address) { byte[] ipAddressRaw = address.getAddress(); return ((ipAddressRaw[0] & 0xFF) << 3 * 8) + ((ipAddressRaw[1] & 0xFF) << 2 * 8) + ((ipAddressRaw[2] & 0xFF) << 1 * 8) + (ipAddressRaw[3] & 0xFF) & 0xffffffffL; } /** * Converts IPv4 Address in long to String. * {@link #longToIpv4(long, long)} fixes the issue of {@link MDSALUtil#longToIp(long, long)} * not handling IP address greater than byte. * * @param ipAddress IP Address to be converted to String * @param mask Network mask to be appended * @return IP Address converted to String */ public static String longToIpv4(final long ipAddress, final long mask) { final StringBuilder builder = new StringBuilder(20); final Inet4Address address = InetAddresses.fromInteger((int) ipAddress); builder.append(address.toString()); if (mask != 0) { builder.append("/").append(mask); } return builder.toString(); } public static int ipAddressToInt(String ipAddr) throws UnknownHostException { InetAddress subnetAddress = InetAddress.getByName(ipAddr); return Ints.fromByteArray(subnetAddress.getAddress()); } public static byte[] parseMacAddress(String macAddress) { byte cur; String[] addressPart = macAddress.split(NwConstants.MACADDR_SEP); int size = addressPart.length; byte[] part = new byte[size]; for (int i = 0; i < size; i++) { cur = UnsignedBytes.parseUnsignedByte(addressPart[i], 16); part[i] = cur; } return part; } public static String toStringIpAddress(byte[] ipAddress) { if (ipAddress == null) { return ""; } try { return InetAddress.getByAddress(ipAddress).getHostAddress(); } catch (UnknownHostException e) { // educated guess on separator String sep = ipAddress.length <= 4 ? NwConstants.IPV4_SEP : NwConstants.IPV6_SEP; StringBuilder sb = new StringBuilder(ipAddress.length * 2); for (byte b : ipAddress) { sb.append(b).append(sep); } LOG.error("toStringIpAddress: Unable to translate byte[]={} to String representation", sb.deleteCharAt(sb.lastIndexOf(sep)).toString(), e); } return ""; } /** * Accepts a MAC address and returns the corresponding long, where the MAC * bytes are set on the lower order bytes of the long. * * @return a long containing the mac address bytes */ public static long macByteToLong(byte[] macAddress) { long mac = 0; for (int i = 0; i < 6; i++) { long temp = (macAddress[i] & 0xffL) << (5 - i) * 8; mac |= temp; } return mac; } /** * Accepts a MAC address of the form 00:aa:11:bb:22:cc, case does not * matter, and returns the corresponding long, where the MAC bytes are set * on the lower order bytes of the long. * * @param macAddress * in String format * @return a long containing the mac address bytes */ public static long macToLong(MacAddress macAddress) { return macByteToLong(parseMacAddress(macAddress.getValue())); } public static String toStringMacAddress(byte[] macAddress) { if (macAddress == null) { return ""; } StringBuilder sb = new StringBuilder(18); for (byte macAddres : macAddress) { String tmp = UnsignedBytes.toString(macAddres, 16).toUpperCase(); if (tmp.length() == 1 || macAddres == (byte) 0) { sb.append("0"); } sb.append(tmp); sb.append(NwConstants.MACADDR_SEP); } sb.setLength(17); return sb.toString(); } /** * Returns the ids of the currently operative DPNs. */ public static List<BigInteger> getOperativeDPNs(DataBroker dataBroker) { List<BigInteger> result = new LinkedList<>(); InstanceIdentifier<Nodes> nodesInstanceIdentifier = InstanceIdentifier.builder(Nodes.class).build(); Optional<Nodes> nodesOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, nodesInstanceIdentifier); if (!nodesOptional.isPresent()) { return result; } Nodes nodes = nodesOptional.get(); List<Node> nodeList = nodes.getNode(); for (Node node : nodeList) { NodeId nodeId = node.getId(); if (nodeId != null) { BigInteger dpnId = MDSALUtil.getDpnIdFromNodeName(nodeId); result.add(dpnId); } } return result; } /** * Utility API to check if the supplied ipAddress is IPv4 Address. * * @param ipAddress string-ified text of a possible IP address * @return true if ipAddress is an IPv4Address and false otherwise */ public static Boolean isIpv4Address(String ipAddress) { try { InetAddress address = InetAddress.getByName(ipAddress); return address instanceof Inet4Address; } catch (UnknownHostException e) { final String msg = "UnknownHostException while checking whether '" + ipAddress + "' is an IPv4 address"; // Double LOG & re-throw anti pattern usually bad, exceptionally OK here, just to be sure this is seen: LOG.error(msg, e); throw new RuntimeException(msg, e); } } /** * Checks if a given ipAddress belongs to a specific subnet. * * @param ipAddress The Ip Address to check * @param subnetCidr Subnet represented as string with CIDR * @return true if the ipAddress belongs to the Subnet, or false if it * doesnt belong or the IpAddress string cannot be converted to an * InetAddress */ public static boolean isIpInSubnet(int ipAddress, String subnetCidr) { String[] subSplit = subnetCidr.split("/"); if (subSplit.length < 2) { return false; } String subnetStr = subSplit[0]; int prefixLength = Integer.parseInt(subSplit[1]); try { int subnet = ipAddressToInt(subnetStr); int mask = -1 << 32 - prefixLength; return (subnet & mask) == (ipAddress & mask); } catch (UnknownHostException ex) { LOG.error("Subnet string {} not convertible to InetAdddress ", subnetStr, ex); return false; } } /** * Utility API that returns the corresponding ipPrefix based on the ipAddress. * * @param ipAddress string text of an IP address * @return ipAddress appended with a "/32" prefix (if IPv4), else "/128" prefix (for IPv6) */ public static String toIpPrefix(String ipAddress) { return isIpv4Address(ipAddress) ? ipAddress + NwConstants.IPV4PREFIX : ipAddress + NwConstants.IPV6PREFIX; } }