com.bluecatcode.common.base.Environment Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava-15.0-extended Show documentation
Guava library extensions.
There is a newer version: 1.1.0
package com.bluecatcode.common.base;

import com.google.common.annotations.Beta;
import com.google.common.base.Optional;

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.logging.Level;
import java.util.logging.Logger;

import static com.google.common.base.Strings.emptyToNull;
import static java.lang.String.format;

/**
 * Provides easy and safe access to environment variables, system properties, etc.
 */
@Beta
public class Environment {

    private static final Logger log = Logger.getLogger(Environment.class.getName());

    /**
     * @see java.net.InetAddress#getHostName()
     * @return the local host name
     */
    public static Optional getLocalHostName() {
        try {
            String hostName = getLocalHostNameWithRecovery();
            return Optional.fromNullable(hostName);
        } catch (UnknownHostException e) {
            log.log(Level.FINE, "Cannot get localhost name", e);
            return Optional.absent();
        }
    }

    /**
     * When using the {@link java.net.InetAddress#getHostName()} method in an
     * environment where neither a proper DNS lookup nor an /etc/hosts
     * entry exists for a given host, the following exception will be thrown:
     * 
     * 
     * java.net.UnknownHostException: <hostname>: <hostname>
     * at java.net.InetAddress.getLocalHost(InetAddress.java:1425)
     * ...
     * 
     * 
     * Instead of just throwing an UnknownHostException and giving up, this
     * method grabs a suitable hostname from the exception and prevents the
     * exception from being thrown. If a suitable hostname cannot be acquired
     * from the exception, only then is the UnknownHostException thrown.
     *
     * @return the hostname
     * @throws java.net.UnknownHostException is thrown if hostname could not be resolved
     */
    private static String getLocalHostNameWithRecovery() throws UnknownHostException {
        try {
            return (InetAddress.getLocalHost()).getHostName();
        } catch (UnknownHostException exception) {
            String host = exception.getMessage(); // host = "hostname: hostname"
            if (host != null) {
                int colon = host.indexOf(':');
                if (colon > 0) {
                    return host.substring(0, colon);
                }
            }
            throw exception;
        }
    }

    /**
     * @see System#getenv(String)
     * @param name the environment variable name
     * @return the environment variable value
     */
    public static Optional getEnvironmentVariable(String name) {
        return Optional.fromNullable(
                emptyToNull(System.getenv(name))
        );
    }

    /**
     * @see System#getProperty(String)
     * @param name the system property name
     * @return the system property value
     */
    public static Optional getSystemProperty(String name) {
        return Optional.fromNullable(
                emptyToNull(System.getProperty(name))
        );
    }

    /**
     * The minimum number of server port number.
     */
    public static final int MIN_PORT_NUMBER = 1;

    /**
     * The maximum number of server port number.
     */
    public static final int MAX_PORT_NUMBER = 49151;

    /**
     * Returns a currently available port number in the specified range.
     * @param fromPort the lower port limit
     * @param toPort the upper port limit
     * @throws IllegalArgumentException if port range is not between {@link #MIN_PORT_NUMBER}
     *      and {@link #MAX_PORT_NUMBER} or fromPort if greater than toPort.
     * @return an available port
     */
    public static int getNextAvailablePort(int fromPort, int toPort) {
        if (fromPort < MIN_PORT_NUMBER || toPort > MAX_PORT_NUMBER || fromPort > toPort) {
            throw new IllegalArgumentException(format("Invalid port range: %d ~ %d", fromPort, toPort));
        }

        int nextPort = fromPort;
        //noinspection StatementWithEmptyBody
        while (!isPortAvailable(nextPort++)) { /* Empty */ }
        return nextPort;
    }

    /**
     * Returns a currently available port number in range from the lower bound to {@link #MAX_PORT_NUMBER}.
     * @param fromPort the lower port limit
     * @return an available port
     */
    public static int getNextAvailablePort(int fromPort) {
        return getNextAvailablePort(fromPort, MAX_PORT_NUMBER);
    }

    /**
     * Checks if a port is available by opening a socket on it
     * @param port the port to test
     * @return true if the port is available
     */
    public static boolean isPortAvailable(int port) {
        StringBuilder builder = new StringBuilder();
        builder.append("Testing port ").append(port).append("\n");
        try (Socket s = new Socket("localhost", port)) {
            // If the code makes it this far without an exception it means
            // something is using the port and has responded.
            builder.append("Port ").append(port).append(" is not available").append("\n");
            return false;
        } catch (IOException e) {
            builder.append("Port ").append(port).append(" is available").append("\n");
            return true;
        } finally {
            log.info(builder.toString());
        }
    }

    private Environment() {
        throw new UnsupportedOperationException();
    }
}