package com.kixeye.kixmpp.server.utils; /* * #%L * KIXMPP * %% * Copyright (C) 2014 KIXEYE, Inc * %% * Licensed 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. * #L% */ import java.net.DatagramSocket; import java.net.ServerSocket; import java.util.Random; import java.util.SortedSet; import java.util.TreeSet; import javax.net.ServerSocketFactory; import org.junit.Assert; /** * NOTE: This code is a copy of that available in the Spring Framework. * * <p>Simple utility methods for working with network sockets — for example, * for finding available ports on {@code localhost}.</p> * * <p>Within this class, a TCP port refers to a port for a {@link ServerSocket}; * whereas, a UDP port refers to a port for a {@link DatagramSocket}.</p> * * @author Sam Brannen * @author Ben Hale * @author Arjen Poutsma * @author Gunnar Hillert * @see <a href="http://spring.io">Borrowed from the Spring Framework</a> * */ public final class SocketUtils { /** * The default minimum value for port ranges used when finding an available * socket port. */ public static final int PORT_RANGE_MIN = 1024; /** * The default maximum value for port ranges used when finding an available * socket port. */ public static final int PORT_RANGE_MAX = 65535; private static final Random random = new Random(System.currentTimeMillis()); /** * Although {@code SocketUtils} consists solely of static utility methods, * this constructor is intentionally {@code public}. * * <h4>Rationale</h4> * * <p>Static methods from this class may be invoked from within XML * configuration files using the Spring Expression Language (SpEL) and the * following syntax. * * <pre><code><bean id="bean1" ... p:port="#{T(org.springframework.util.SocketUtils).findAvailableTcpPort(12000)}" * /></code></pre> * * If this constructor were {@code private}, you would be required to supply * the fully qualified class name to SpEL's {@code T()} function for each usage. * Thus, the fact that this constructor is {@code public} allows you to reduce * boilerplate configuration with SpEL as can be seen in the following example. * * <pre><code><bean id="socketUtils" class="org.springframework.util.SocketUtils" /> * * <bean id="bean1" ... p:port="#{socketUtils.findAvailableTcpPort(12000)}" /> * * <bean id="bean2" ... p:port="#{socketUtils.findAvailableTcpPort(30000)}" /></code></pre> */ public SocketUtils() { /* no-op */ } /** * Find an available TCP port randomly selected from the range * [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}]. * * @return an available TCP port number * * @throws IllegalStateException * if no available port could be found */ public static int findAvailableTcpPort() { return findAvailableTcpPort(PORT_RANGE_MIN); } /** * Find an available TCP port randomly selected from the range * [{@code minPort}, {@value #PORT_RANGE_MAX}]. * * @param minPort * the minimum port number * * @return an available TCP port number * * @throws IllegalStateException * if no available port could be found */ public static int findAvailableTcpPort(int minPort) { return findAvailableTcpPort(minPort, PORT_RANGE_MAX); } /** * Find an available TCP port randomly selected from the range * [{@code minPort}, {@code maxPort}]. * * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return an available TCP port number * * @throws IllegalStateException * if no available port could be found */ public static int findAvailableTcpPort(int minPort, int maxPort) { return SocketType.TCP.findAvailablePort(minPort, maxPort); } /** * Find the requested number of available TCP ports, each randomly selected * from the range [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}]. * * @param numRequested * the number of available ports to find * * @return a sorted set of available TCP port numbers * * @throws IllegalStateException * if the requested number of available ports could not be found */ public static SortedSet<Integer> findAvailableTcpPorts(int numRequested) { return findAvailableTcpPorts(numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX); } /** * Find the requested number of available TCP ports, each randomly selected * from the range [{@code minPort}, {@code maxPort}]. * * @param numRequested * the number of available ports to find * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return a sorted set of available TCP port numbers * * @throws IllegalStateException * if the requested number of available ports could not be found */ public static SortedSet<Integer> findAvailableTcpPorts(int numRequested, int minPort, int maxPort) { return SocketType.TCP.findAvailablePorts(numRequested, minPort, maxPort); } /** * Find an available UDP port randomly selected from the range * [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}]. * * @return an available UDP port number * * @throws IllegalStateException * if no available port could be found */ public static int findAvailableUdpPort() { return findAvailableUdpPort(PORT_RANGE_MIN); } /** * Find an available UDP port randomly selected from the range * [{@code minPort}, {@value #PORT_RANGE_MAX}]. * * @param minPort * the minimum port number * * @return an available UDP port number * * @throws IllegalStateException * if no available port could be found */ public static int findAvailableUdpPort(int minPort) { return findAvailableUdpPort(minPort, PORT_RANGE_MAX); } /** * Find an available UDP port randomly selected from the range * [{@code minPort}, {@code maxPort}]. * * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return an available UDP port number * * @throws IllegalStateException * if no available port could be found */ public static int findAvailableUdpPort(int minPort, int maxPort) { return SocketType.UDP.findAvailablePort(minPort, maxPort); } /** * Find the requested number of available UDP ports, each randomly selected * from the range [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}]. * * @param numRequested * the number of available ports to find * * @return a sorted set of available UDP port numbers * * @throws IllegalStateException * if the requested number of available ports could not be found */ public static SortedSet<Integer> findAvailableUdpPorts(int numRequested) { return findAvailableUdpPorts(numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX); } /** * Find the requested number of available UDP ports, each randomly selected * from the range [{@code minPort}, {@code maxPort}]. * * @param numRequested * the number of available ports to find * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return a sorted set of available UDP port numbers * * @throws IllegalStateException * if the requested number of available ports could not be found */ public static SortedSet<Integer> findAvailableUdpPorts(int numRequested, int minPort, int maxPort) { return SocketType.UDP.findAvailablePorts(numRequested, minPort, maxPort); } private static enum SocketType { TCP { @Override protected boolean isPortAvailable(int port) { try { ServerSocket serverSocket = ServerSocketFactory.getDefault().createServerSocket(port); serverSocket.close(); return true; } catch(Exception ex) { return false; } } }, UDP { @Override protected boolean isPortAvailable(int port) { try { DatagramSocket socket = new DatagramSocket(port); socket.close(); return true; } catch(Exception ex) { return false; } } }; /** * Determine if the specified port for this {@code SocketType} is * currently available on {@code localhost}. */ protected abstract boolean isPortAvailable(int port); /** * Find a pseudo-random port number within the range * [{@code minPort}, {@code maxPort}]. * * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return a random port number within the specified range */ private int findRandomPort(int minPort, int maxPort) { int portRange = maxPort - minPort; return minPort + random.nextInt(portRange); } /** * Find an available port for this {@code SocketType}, randomly selected * from the range [{@code minPort}, {@code maxPort}]. * * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return an available port number for this socket type * * @throws IllegalStateException * if no available port could be found */ int findAvailablePort(int minPort, int maxPort) { Assert.assertTrue("'minPort' must be greater than 0", minPort > 0); Assert.assertTrue("'maxPort' must be greater than 'minPort'", maxPort > minPort); Assert.assertTrue("'maxPort' must be less than or equal to " + PORT_RANGE_MAX, maxPort <= PORT_RANGE_MAX); int portRange = maxPort - minPort; int candidatePort; int searchCounter = 0; do { if(++searchCounter > portRange) { throw new IllegalStateException(String.format( "Could not find an available %s port in the range [%d, %d] after %d attempts", name(), minPort, maxPort, searchCounter)); } candidatePort = findRandomPort(minPort, maxPort); } while(!isPortAvailable(candidatePort)); return candidatePort; } /** * Find the requested number of available ports for this {@code SocketType}, * each randomly selected from the range [{@code minPort}, {@code maxPort}]. * * @param numRequested * the number of available ports to find * @param minPort * the minimum port number * @param maxPort * the maximum port number * * @return a sorted set of available port numbers for this socket type * * @throws IllegalStateException * if the requested number of available ports could not be found */ SortedSet<Integer> findAvailablePorts(int numRequested, int minPort, int maxPort) { Assert.assertTrue("'minPort' must be greater than 0", minPort > 0); Assert.assertTrue("'maxPort' must be greater than 'minPort'", maxPort > minPort); Assert.assertTrue("'maxPort' must be less than or equal to " + PORT_RANGE_MAX, maxPort <= PORT_RANGE_MAX); Assert.assertTrue("'numRequested' must be greater than 0", numRequested > 0); Assert.assertTrue("'numRequested' must not be greater than 'maxPort' - 'minPort'", (maxPort - minPort) >= numRequested); final SortedSet<Integer> availablePorts = new TreeSet<Integer>(); int attemptCount = 0; while((++attemptCount <= numRequested + 100) && (availablePorts.size() < numRequested)) { availablePorts.add(findAvailablePort(minPort, maxPort)); } if(availablePorts.size() != numRequested) { throw new IllegalStateException(String.format( "Could not find %d available %s ports in the range [%d, %d]", numRequested, name(), minPort, maxPort)); } return availablePorts; } } }