org.everrest.assured.util.AvailablePortFinder Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of everrest-assured Show documentation
Testng listener that deploy mock rest services on Jetty with Everrest and tested with rest-assured
The newest version!
/*
 * Copyright (c) 2012-2021 Codenvy, S.A.
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 */
package org.everrest.assured.util;

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.ServerSocket;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.TreeSet;

/**
 * Finds currently available server ports.
 *
 * @author Apache MINA Project
 * @see IANA.org
 */
public class AvailablePortFinder {
  /** 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;

  /** Creates a new instance. */
  private AvailablePortFinder() {
    // Do nothing
  }

  /**
   * Returns the {@link Set} of currently available port numbers ( {@link Integer}). This method is
   * identical to getAvailablePorts(MIN_PORT_NUMBER, MAX_PORT_NUMBER).
   *
   * WARNING: this can take a very long time.
   */
  public static Set getAvailablePorts() {
    return getAvailablePorts(MIN_PORT_NUMBER, MAX_PORT_NUMBER);
  }

  /**
   * Gets the next available port starting at the lowest port number.
   *
   * @throws NoSuchElementException if there are no ports available
   */
  public static int getNextAvailable() {
    return getNextAvailable(MIN_PORT_NUMBER);
  }

  /**
   * Gets the next available port starting at a port.
   *
   * @param fromPort the port to scan for availability
   * @throws NoSuchElementException if there are no ports available
   */
  public static int getNextAvailable(int fromPort) {
    if (fromPort < MIN_PORT_NUMBER || fromPort > MAX_PORT_NUMBER) {
      throw new IllegalArgumentException("Invalid start port: " + fromPort);
    }

    for (int i = fromPort; i <= MAX_PORT_NUMBER; i++) {
      if (available(i)) {
        return i;
      }
    }

    throw new NoSuchElementException("Could not find an available port " + "above " + fromPort);
  }

  /**
   * 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 < MIN_PORT_NUMBER || 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) {
      // Do nothing
    } finally {
      if (ds != null) {
        ds.close();
      }

      if (ss != null) {
        try {
          ss.close();
        } catch (IOException e) {
          /* should not be thrown */
        }
      }
    }

    return false;
  }

  /**
   * Returns the {@link Set} of currently avaliable port numbers ( {@link Integer}) between the
   * specified port range.
   *
   * @throws IllegalArgumentException if port range is not between {@link #MIN_PORT_NUMBER} and
   *     {@link #MAX_PORT_NUMBER} or fromPort if greater than toPort.
   */
  public static Set getAvailablePorts(int fromPort, int toPort) {
    if (fromPort < MIN_PORT_NUMBER || toPort > MAX_PORT_NUMBER || fromPort > toPort) {
      throw new IllegalArgumentException("Invalid port range: " + fromPort + " ~ " + toPort);
    }

    Set result = new TreeSet();

    for (int i = fromPort; i <= toPort; i++) {
      ServerSocket s = null;

      try {
        s = new ServerSocket(i);
        result.add(Integer.valueOf(i));
      } catch (IOException e) {
        // Do nothing
      } finally {
        if (s != null) {
          try {
            s.close();
          } catch (IOException e) {
            /* should not be thrown */
          }
        }
      }
    }

    return result;
  }
}