org.eclipse.jetty.http.HttpScheme Java Examples

/**
 * Verifies all the needed bits are present in Jetty XML configuration (as HTTPS must be enabled by users).
 */
private void verifyConfiguration(final HttpScheme httpScheme) {
  try {
    if (HttpScheme.HTTP == httpScheme) {
      bean(HTTP_CONFIG_ID, HttpConfiguration.class);
      bean(HTTP_CONNECTOR_ID, ServerConnector.class);
    }
    else if (HttpScheme.HTTPS == httpScheme) {
      bean(SSL_CONTEXT_FACTORY_ID, SslContextFactory.class);
      bean(HTTPS_CONFIG_ID, HttpConfiguration.class);
      bean(HTTPS_CONNECTOR_ID, ServerConnector.class);
    }
    else {
      throw new UnsupportedHttpSchemeException(httpScheme);
    }
  }
  catch (IllegalStateException e) {
    throw new IllegalStateException("Jetty HTTPS is not enabled in Nexus", e);
  }
}
 

private void validate(final ConnectorConfiguration connectorConfiguration) {
  // connector is not already added
  checkArgument(!managedConfigurations.containsKey(connectorConfiguration));

  // schema is not null and is available
  final HttpScheme httpScheme = connectorConfiguration.getScheme();
  checkNotNull(httpScheme);
  if (!availableSchemes().contains(httpScheme)) {
    throw new UnsupportedHttpSchemeException(httpScheme);
  }

  // port is ok and free
  final int port = connectorConfiguration.getPort();
  checkArgument(port > 0);
  checkArgument(port < 65536);
  checkArgument(!unavailablePorts().contains(port));
}
 

/**
 * Returns the OOTB defined configuration for given HTTP scheme.
 */
private HttpConfiguration defaultHttpConfiguration(final HttpScheme httpScheme) {
  if (HttpScheme.HTTP == httpScheme) {
    return bean(HTTP_CONFIG_ID, HttpConfiguration.class);
  }
  else if (HttpScheme.HTTPS == httpScheme) {
    return bean(HTTPS_CONFIG_ID, HttpConfiguration.class);
  }
  else {
    throw new UnsupportedHttpSchemeException(httpScheme);
  }
}
 

/**
 * Returns the OOTB defined connector for given HTTP scheme.
 */
private ServerConnector defaultConnector(final HttpScheme httpScheme) {
  if (HttpScheme.HTTP == httpScheme) {
    return bean(HTTP_CONNECTOR_ID, ServerConnector.class);
  }
  else if (HttpScheme.HTTPS == httpScheme) {
    return bean(HTTPS_CONNECTOR_ID, ServerConnector.class);
  }
  else {
    throw new UnsupportedHttpSchemeException(httpScheme);
  }
}
 

@Override
public List<HttpScheme> availableSchemes() {
  final List<HttpScheme> result = new ArrayList<>();
  for (ConnectorConfiguration defaultConnector : serverConfiguration.defaultConnectors()) {
    result.add(defaultConnector.getScheme());
  }
  return result;
}
 

/**
 * Checks if the request was made over HTTPS. If so it modifies the request so that
 * {@code HttpServletRequest#isSecure()} returns true, {@code HttpServletRequest#getScheme()}
 * returns "https", and {@code HttpServletRequest#getServerPort()} returns 443. Otherwise it sets
 * the scheme to "http" and port to 80.
 *
 * @param request The request to modify.
 */
private void setSchemeAndPort(Request request) {
  String https = request.getHeader(VmApiProxyEnvironment.HTTPS_HEADER);
  String proto = request.getHeader(VmApiProxyEnvironment.X_FORWARDED_PROTO_HEADER);
  if ("on".equals(https) || "https".equals(proto)) {
    request.setSecure(true);
    request.setScheme(HttpScheme.HTTPS.toString());
    request.setAuthority(request.getServerName(), 443);
  } else {
    request.setSecure(false);
    request.setScheme(HttpScheme.HTTP.toString());
    request.setAuthority(request.getServerName(), defaultEnvironment.getServerPort());
  }
}
 

public UnsupportedHttpSchemeException(final HttpScheme httpScheme) {
  super("Unsupported HTTP Scheme: " + httpScheme);
  this.httpScheme = httpScheme;
}
 

public HttpScheme getHttpScheme() {
  return httpScheme;
}
 

/**
 * Returns the list of available HTTP schemes. This list depends on current Jetty XML configuration (is HTTPS
 * enabled). If schema is not available, method {@link #addConnector(ConnectorConfiguration)} will reject to add it.
 */
List<HttpScheme> availableSchemes();
 

/**
 * The required connector scheme.
 */
HttpScheme getScheme();