Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.hama.util; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ConnectException; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.NetworkInterface; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketAddress; import java.net.SocketException; import java.net.URI; import java.net.UnknownHostException; import java.nio.channels.SocketChannel; import java.util.HashMap; import java.util.Map; import java.util.NoSuchElementException; import javax.net.SocketFactory; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.net.NetUtils; import org.apache.hadoop.security.SecurityUtil; import org.apache.hama.Constants; import org.apache.hama.ipc.Server; /** * NetUtils for our needs. */ public class BSPNetUtils { public static final Log LOG = LogFactory.getLog(BSPNetUtils.class); public static final int MAX_PORT_NUMBER = 65535; private static Map<String, String> hostToResolved = new HashMap<String, String>(); /** * Gets the canonical hostname of this machine. * * @return String representing host canonical host name * @throws UnknownHostException */ public static String getCanonicalHostname() throws UnknownHostException { return InetAddress.getLocalHost().getCanonicalHostName(); } /** * Uses Minas AvailablePortFinder to find a port, starting at 14000. * * @return a free port. */ public static int getFreePort() { int startPort = 14000; return getFreePort(startPort); } /** * Uses Minas AvailablePortFinder to find a port, starting at startPort. * * @return a free port. */ public static int getFreePort(int pStartPort) { int startPort = pStartPort; while (!available(startPort)) { startPort++; } return startPort; } /** * Gets a new InetSocketAddress from the given peerName. peerName must contain * a colon to distinct between host and port. * * @param peerName the name as a String of the BSP peer to get the address * from * @return the InetSocketAddress of the given BSP peer */ public static InetSocketAddress getAddress(String peerName) { int index = peerName.lastIndexOf(':'); if (index <= 0 || index == peerName.length() - 1) { throw new ArrayIndexOutOfBoundsException("Invalid host and port information. " + "Peername must consist of atleast ONE \":\"! " + "Given peername was: " + peerName); } return new InetSocketAddress(peerName.substring(0, index), Integer.valueOf(peerName.substring(index + 1))); } /** * Checks to see if a specific port is available. * * @param port the port to check for availability */ public static boolean available(int port) { if (port < 1000 || port > MAX_PORT_NUMBER) { throw new IllegalArgumentException("Invalid start port: " + port); } ServerSocket ss = null; DatagramSocket ds = null; try { ss = new ServerSocket(port); ss.setReuseAddress(true); ds = new DatagramSocket(port); ds.setReuseAddress(true); return true; } catch (IOException e) { } finally { if (ds != null) { ds.close(); } if (ss != null) { try { ss.close(); } catch (IOException e) { /* should not be thrown */ } } } return false; } public static int getNextAvailable(int fromPort) { if ((fromPort < Constants.DEFAULT_PEER_PORT) || (fromPort > MAX_PORT_NUMBER)) { throw new IllegalArgumentException("Invalid start port: " + fromPort); } for (int i = fromPort + 1; i <= MAX_PORT_NUMBER; i++) { if (available(i)) { return i; } } throw new NoSuchElementException("Could not find an available port " + "above " + fromPort); } /** * Returns InetSocketAddress that a client can use to connect to the server. * Server.getListenerAddress() is not correct when the server binds to * "0.0.0.0". This returns "127.0.0.1:port" when the getListenerAddress() * returns "0.0.0.0:port". * * @param server * @return socket address that a client can use to connect to the server. */ public static InetSocketAddress getConnectAddress(Server server) { InetSocketAddress addr = server.getListenerAddress(); if (addr.getAddress().isAnyLocalAddress()) { addr = makeSocketAddr("127.0.0.1", addr.getPort()); } return addr; } /** * Create a socket address with the given host and port. The hostname might be * replaced with another host that was set via * {@link NetUtils#addStaticResolution(String, String)}. The value of * hadoop.security.token.service.use_ip will determine whether the standard * java host resolver is used, or if the fully qualified resolver is used. * * @param host the hostname or IP use to instantiate the object * @param port the port number * @return InetSocketAddress */ public static InetSocketAddress makeSocketAddr(String host, int port) { String staticHost = getStaticResolution(host); String resolveHost = (staticHost != null) ? staticHost : host; InetSocketAddress addr; try { InetAddress iaddr = SecurityUtil.getByName(resolveHost); // if there is a static entry for the host, make the returned // address look like the original given host if (staticHost != null) { iaddr = InetAddress.getByAddress(host, iaddr.getAddress()); } addr = new InetSocketAddress(iaddr, port); } catch (UnknownHostException e) { addr = InetSocketAddress.createUnresolved(host, port); } return addr; } /** * Retrieves the resolved name for the passed host. The resolved name must * have been set earlier using * {@link NetUtils#addStaticResolution(String, String)} * * @param host * @return the resolution */ public static String getStaticResolution(String host) { synchronized (hostToResolved) { return hostToResolved.get(host); } } /** * Handle the transition from pairs of attributes specifying a host and port * to a single colon separated one. * * @param conf the configuration to check * @param oldBindAddressName the old address attribute name * @param oldPortName the old port attribute name * @param newBindAddressName the new combined name * @return the complete address from the configuration */ public static String getServerAddress(Configuration conf, String oldBindAddressName, String oldPortName, String newBindAddressName) { String oldAddr = conf.get(oldBindAddressName); String oldPort = conf.get(oldPortName); String newAddrPort = conf.get(newBindAddressName); if (oldAddr == null && oldPort == null) { return newAddrPort; } String[] newAddrPortParts = newAddrPort.split(":", 2); if (newAddrPortParts.length != 2) { throw new IllegalArgumentException("Invalid address/port: " + newAddrPort); } if (oldAddr == null) { oldAddr = newAddrPortParts[0]; } else { LOG.warn("Configuration parameter " + oldBindAddressName + " is deprecated. Use " + newBindAddressName + " instead."); } if (oldPort == null) { oldPort = newAddrPortParts[1]; } else { LOG.warn("Configuration parameter " + oldPortName + " is deprecated. Use " + newBindAddressName + " instead."); } return oldAddr + ":" + oldPort; } /** * Util method to build socket addr from either: <host>:<post> * <fs>://<host>:<port>/<path> */ public static InetSocketAddress createSocketAddr(String target) { return createSocketAddr(target, -1); } /** * Util method to build socket addr from either: <host> <host>:<post> * <fs>://<host>:<port>/<path> */ public static InetSocketAddress createSocketAddr(String target, int defaultPort) { if (target == null) { throw new IllegalArgumentException("Socket address is null"); } boolean hasScheme = target.contains("://"); URI uri = null; try { uri = hasScheme ? URI.create(target) : URI.create("dummyscheme://" + target); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Does not contain a valid host:port authority: " + target); } String host = uri.getHost(); int port = uri.getPort(); if (port == -1) { port = defaultPort; } String path = uri.getPath(); if ((host == null) || (port < 0) || (!hasScheme && path != null && !path.isEmpty())) { throw new IllegalArgumentException("Does not contain a valid host:port authority: " + target); } return makeSocketAddr(host, port); } /** * Checks if {@code host} is a local host name and return {@link InetAddress} * corresponding to that address. * * @param host the specified host * @return a valid local {@link InetAddress} or null * @throws SocketException if an I/O error occurs */ public static InetAddress getLocalInetAddress(String host) throws SocketException { if (host == null) { return null; } InetAddress addr = null; try { addr = InetAddress.getByName(host); if (NetworkInterface.getByInetAddress(addr) == null) { addr = null; // Not a local address } } catch (UnknownHostException ignore) { } return addr; } /** * This is a drop-in replacement for * {@link Socket#connect(SocketAddress, int)}. In the case of normal sockets * that don't have associated channels, this just invokes * <code>socket.connect(endpoint, timeout)</code>. If * <code>socket.getChannel()</code> returns a non-null channel, connect is * implemented using Hadoop's selectors. This is done mainly to avoid Sun's * connect implementation from creating thread-local selectors, since Hadoop * does not have control on when these are closed and could end up taking all * the available file descriptors. * * @see java.net.Socket#connect(java.net.SocketAddress, int) * * @param socket * @param address the remote address * @param timeout timeout in milliseconds */ public static void connect(Socket socket, SocketAddress address, int timeout) throws IOException { connect(socket, address, null, timeout); } /** * Like {@link NetUtils#connect(Socket, SocketAddress, int)} but also takes a * local address and port to bind the socket to. * * @param socket * @param endpoint the remote address * @param localAddr the local address to bind the socket to * @param timeout timeout in milliseconds */ public static void connect(Socket socket, SocketAddress endpoint, SocketAddress localAddr, int timeout) throws IOException { if (socket == null || endpoint == null || timeout < 0) { throw new IllegalArgumentException("Illegal argument for connect()"); } SocketChannel ch = socket.getChannel(); if (localAddr != null) { socket.bind(localAddr); } if (ch == null) { // let the default implementation handle it. socket.connect(endpoint, timeout); } else { SocketIOWithTimeout.connect(ch, endpoint, timeout); } // There is a very rare case allowed by the TCP specification, such that // if we are trying to connect to an endpoint on the local machine, // and we end up choosing an ephemeral port equal to the destination port, // we will actually end up getting connected to ourself (ie any data we // send just comes right back). This is only possible if the target // daemon is down, so we'll treat it like connection refused. if (socket.getLocalPort() == socket.getPort() && socket.getLocalAddress().equals(socket.getInetAddress())) { LOG.info("Detected a loopback TCP socket, disconnecting it"); socket.close(); throw new ConnectException("Localhost targeted connection resulted in a loopback. " + "No daemon is listening on the target port."); } } /** * Same as getInputStream(socket, socket.getSoTimeout()).<br> * <br> * * From documentation for {@link #getInputStream(Socket, long)}:<br> * Returns InputStream for the socket. If the socket has an associated * SocketChannel then it returns a {@link SocketInputStream} with the given * timeout. If the socket does not have a channel, * {@link Socket#getInputStream()} is returned. In the later case, the timeout * argument is ignored and the timeout set with * {@link Socket#setSoTimeout(int)} applies for reads.<br> * <br> * * Any socket created using socket factories returned by {@link NetUtils}, * must use this interface instead of {@link Socket#getInputStream()}. * * @see #getInputStream(Socket, long) * * @param socket * @return InputStream for reading from the socket. * @throws IOException */ public static InputStream getInputStream(Socket socket) throws IOException { return getInputStream(socket, socket.getSoTimeout()); } /** * Returns InputStream for the socket. If the socket has an associated * SocketChannel then it returns a {@link SocketInputStream} with the given * timeout. If the socket does not have a channel, * {@link Socket#getInputStream()} is returned. In the later case, the timeout * argument is ignored and the timeout set with * {@link Socket#setSoTimeout(int)} applies for reads.<br> * <br> * * Any socket created using socket factories returned by {@link NetUtils}, * must use this interface instead of {@link Socket#getInputStream()}. * * @see Socket#getChannel() * * @param socket * @param timeout timeout in milliseconds. This may not always apply. zero for * waiting as long as necessary. * @return InputStream for reading from the socket. * @throws IOException */ public static InputStream getInputStream(Socket socket, long timeout) throws IOException { return (socket.getChannel() == null) ? socket.getInputStream() : new SocketInputStream(socket, timeout); } /** * Same as getOutputStream(socket, 0). Timeout of zero implies write will wait * until data is available.<br> * <br> * * From documentation for {@link #getOutputStream(Socket, long)} : <br> * Returns OutputStream for the socket. If the socket has an associated * SocketChannel then it returns a {@link SocketOutputStream} with the given * timeout. If the socket does not have a channel, * {@link Socket#getOutputStream()} is returned. In the later case, the * timeout argument is ignored and the write will wait until data is * available.<br> * <br> * * Any socket created using socket factories returned by {@link NetUtils}, * must use this interface instead of {@link Socket#getOutputStream()}. * * @see #getOutputStream(Socket, long) * * @param socket * @return OutputStream for writing to the socket. * @throws IOException */ public static OutputStream getOutputStream(Socket socket) throws IOException { return getOutputStream(socket, 0); } /** * Returns OutputStream for the socket. If the socket has an associated * SocketChannel then it returns a {@link SocketOutputStream} with the given * timeout. If the socket does not have a channel, * {@link Socket#getOutputStream()} is returned. In the later case, the * timeout argument is ignored and the write will wait until data is * available.<br> * <br> * * Any socket created using socket factories returned by {@link NetUtils}, * must use this interface instead of {@link Socket#getOutputStream()}. * * @see Socket#getChannel() * * @param socket * @param timeout timeout in milliseconds. This may not always apply. zero for * waiting as long as necessary. * @return OutputStream for writing to the socket. * @throws IOException */ public static OutputStream getOutputStream(Socket socket, long timeout) throws IOException { return (socket.getChannel() == null) ? socket.getOutputStream() : new SocketOutputStream(socket, timeout); } /** * Get the default socket factory as specified by the configuration parameter * <tt>hadoop.rpc.socket.factory.default</tt> * * @param conf the configuration * @return the default socket factory as specified in the configuration or the * JVM default socket factory if the configuration does not contain a * default socket factory property. */ public static SocketFactory getDefaultSocketFactory(Configuration conf) { String propValue = conf.get("hadoop.rpc.socket.factory.class.default"); if ((propValue == null) || (propValue.length() == 0)) return SocketFactory.getDefault(); return getSocketFactoryFromProperty(conf, propValue); } /** * Get the socket factory corresponding to the given proxy URI. If the given * proxy URI corresponds to an absence of configuration parameter, returns * null. If the URI is malformed raises an exception. * * @param propValue the property which is the class name of the SocketFactory * to instantiate; assumed non null and non empty. * @return a socket factory as defined in the property value. */ public static SocketFactory getSocketFactoryFromProperty(Configuration conf, String propValue) { try { Class<?> theClass = conf.getClassByName(propValue); return (SocketFactory) org.apache.hadoop.util.ReflectionUtils.newInstance(theClass, conf); } catch (ClassNotFoundException cnfe) { throw new RuntimeException("Socket Factory class not found: " + cnfe); } } }