How to use

HttpConfiguration

in

org.eclipse.jetty.server

final Server server = new Server(new JettyConnectorThreadPool());
final HttpConfiguration config = new HttpConfiguration();
if (sslContextFactory != null) {
  config.setSecureScheme("https");
  config.setSecurePort(port);
  config.addCustomizer(new SecureRequestCustomizer());
  final ServerConnector https = new ServerConnector(server,
      new SslConnectionFactory(sslContextFactory, "http/1.1"),
      new HttpConnectionFactory(config));
  https.setPort(port);
  server.setConnectors(new Connector[]{https});
  final ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(config));
  http.setPort(port);
  server.setConnectors(new Connector[]{http});

  new QueuedThreadPool(maxThreads, minThreads, idleTimeout);
Server server = new Server(threadPool);
server.addEventListener(mbContainer);
server.addBean(mbContainer);
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(servicePort);
httpConfig.setSendServerVersion(false);
httpConfig.setSendDateHeader(false);
 HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
 httpsConfig.addCustomizer(new SecureRequestCustomizer());
 SslContextFactory sslCtxFactory = new SslContextFactory();
 String keystore = conf.get(REST_SSL_KEYSTORE_STORE);
 String password = HBaseConfiguration.getPassword(conf,
 String keyPassword = HBaseConfiguration.getPassword(conf,
   REST_SSL_KEYSTORE_KEYPASSWORD, password);
 sslCtxFactory.setKeyStorePath(keystore);
 sslCtxFactory.setKeyStorePassword(password);
 sslCtxFactory.setKeyManagerPassword(keyPassword);
 serverConnector.setAcceptQueueSize(acceptQueueSize);

QueuedThreadPool threadPool = new QueuedThreadPool(maxThreads);
threadPool.setMinThreads(minThreads);
httpServer = new Server(threadPool);
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(listenPort);
httpConfig.setHeaderCacheSize(DEFAULT_HTTP_MAX_HEADER_SIZE);
httpConfig.setRequestHeaderSize(DEFAULT_HTTP_MAX_HEADER_SIZE);
httpConfig.setResponseHeaderSize(DEFAULT_HTTP_MAX_HEADER_SIZE);
httpConfig.setSendServerVersion(false);
httpConfig.setSendDateHeader(false);
 HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig);
 httpsConfig.addCustomizer(new SecureRequestCustomizer());
 SslContextFactory sslCtxFactory = new SslContextFactory();
 String keystore = conf.get(THRIFT_SSL_KEYSTORE_STORE_KEY);
 String password = HBaseConfiguration.getPassword(conf,
serverConnector.setPort(listenPort);
serverConnector.setHost(getBindAddress(conf).getHostAddress());
httpServer.addConnector(serverConnector);
httpServer.setStopAtShutdown(true);

private static HttpConnectionFactory createHttpConnectionFactory() {
  HttpConfiguration httpConfig = new HttpConfiguration();
  httpConfig.setSecureScheme("https");
  httpConfig.addCustomizer(new ForwardedRequestCustomizer());
  return new HttpConnectionFactory(httpConfig);
}

protected HttpConfiguration createHttpConfig()
{
  HttpConfiguration httpConfig = new HttpConfiguration();
  httpConfig.setRequestHeaderSize( configuration.get( ServerSettings.maximum_request_header_size) );
  httpConfig.setResponseHeaderSize( configuration.get( ServerSettings.maximum_response_header_size) );
  httpConfig.setSendServerVersion( false );
  return httpConfig;
}

@Override
protected HttpConfiguration buildHttpConfiguration() {
  final HttpConfiguration config = super.buildHttpConfiguration();
  config.setSecureScheme("https");
  config.setSecurePort(getPort());
  config.addCustomizer(new SecureRequestCustomizer());
  return config;
}

private void setUpSSlServer2() throws Exception {
  server2 = new Server();
  HttpConfiguration https_config = new HttpConfiguration();
  https_config.setSecureScheme("https");
  https_config.setSecurePort(port2);
  https_config.setOutputBufferSize(32768);
  SecureRequestCustomizer src = new SecureRequestCustomizer();
  src.setStsMaxAge(2000);
  src.setStsIncludeSubDomains(true);
  https_config.addCustomizer(src);
  SslContextFactory sslContextFactory = new SslContextFactory();
  ClassLoader cl = getClass().getClassLoader();
  URL cacertsUrl = cl.getResource("ssltest-cacerts.jks");
  String trustStoreFile = new File(cacertsUrl.toURI()).getAbsolutePath();
  sslContextFactory.setTrustStorePath(trustStoreFile);
  sslContextFactory.setTrustStorePassword("changeit");
  sslContextFactory.setTrustStoreType("JKS");
  ServerConnector https_connector = new ServerConnector(server2,
      new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
      new HttpConnectionFactory(https_config));
  https_connector.setPort(port2);
  https_connector.setIdleTimeout(500000);
  setUpServers(https_connector);

Server server = new Server();
handlers.setHandlers(new Handler[]{staticResourceHandler, servletContextHandler});
server.setHandler(handlers);
HttpConfiguration http_config = new HttpConfiguration();
http_config.setSecureScheme("https");
http_config.setSecurePort(Integer.parseInt(globalProps.getProperty("serverPort")));
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setKeyStorePath(keystoreFile.getAbsolutePath());
  sslContextFactory.setKeyStorePassword(globalProps.getProperty("keystorePwd"));
  sslContextFactory.setKeyManagerPassword(globalProps.getProperty("keystoreManagerPwd"));
  HttpConfiguration https_config = new HttpConfiguration(http_config);
  https_config.addCustomizer(new SecureRequestCustomizer());
  ServerConnector https = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(https_config));
  https.setPort(Integer.parseInt(globalProps.getProperty("serverPort")));
  server.setConnectors(new Connector[]{https});
} else {
  if(globalProps.getProperty("X-Forwarded-For").equals("true")) {
    http_config.addCustomizer(new org.eclipse.jetty.server.ForwardedRequestCustomizer());
  ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(http_config));
  http.setPort(Integer.parseInt(globalProps.getProperty("serverPort")));
  server.setConnectors(new Connector[]{http});

  m_server = new Server(m_pool);
else
  m_server = new Server();
m_server.addBean(errorHandler);
  ServerConnector http = new ServerConnector(m_server);
  http.setHost(m_address.getHostName());
  http.setPort(m_port);
  m_server.addConnector(http);
  HttpConfiguration httpConfig = new HttpConfiguration();
  httpConfig.setSecureScheme("https");
  httpConfig.setSecurePort(m_sslPort);
  httpConfig.addCustomizer(new SecureRequestCustomizer());
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setKeyStorePath(m_keyStorePath);
  sslContextFactory.setKeyStorePassword(m_keyStorePassword);
    sslContextFactory.setIncludeProtocols(m_protocols);
  ServerConnector https = new ServerConnector(m_server, new SslConnectionFactory(sslContextFactory,"http/1.1"), new HttpConnectionFactory(httpConfig));
  https.setPort(m_sslPort);

 FlumeBeanConfigurator.setConfigurationFields(threadPool, sourceContext);
srv = new Server(threadPool);
srv.addEventListener(mbContainer);
srv.addBean(mbContainer);
HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.addCustomizer(new SecureRequestCustomizer());
 SslContextFactory sslCtxFactory = new SslContextFactory();
 sslCtxFactory.setSslContext(sslContext);
 sslCtxFactory.setExcludeProtocols(getExcludeProtocols().toArray(new String[]{}));
 sslCtxFactory.setIncludeProtocols(getIncludeProtocols().toArray(new String[]{}));
 sslCtxFactory.setExcludeCipherSuites(getExcludeCipherSuites().toArray(new String[]{}));
 httpConfiguration.setSecurePort(port);
 httpConfiguration.setSecureScheme("https");
connector.setPort(port);
connector.setHost(host);
connector.setReuseAddress(true);

tp.setName("Jetty-QTP-AdminConsole");
adminServer = new Server(tp);
  adminServer.addBean(jmx.getContainer());
  final HttpConfiguration httpConfig = new HttpConfiguration();
  httpConfig.setSendServerVersion( false );
  final ServerConnector httpConnector = new ServerConnector(adminServer, null, null, null, -1, serverThreads, new HttpConnectionFactory(httpConfig));
  httpConnector.setHost(bindInterface);
  httpConnector.setPort(adminPort);
  adminServer.addConnector(httpConnector);
      final SslContextFactory sslContextFactory = new EncryptionArtifactFactory( configuration ).getSslContextFactory();
      final HttpConfiguration httpsConfig = new HttpConfiguration();
      httpsConfig.setSendServerVersion( false );
      httpsConfig.setSecureScheme( "https" );
      httpsConfig.setSecurePort( adminSecurePort );
      httpsConfig.addCustomizer( new SecureRequestCustomizer() );
      final HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory( httpsConfig );
      final SslConnectionFactory sslConnectionFactory = new SslConnectionFactory( sslContextFactory, org.eclipse.jetty.http.HttpVersion.HTTP_1_1.toString() );
      final ServerConnector httpsConnector = new ServerConnector( adminServer, null, null, null, -1, serverThreads, sslConnectionFactory, httpConnectionFactory );

@Override
public void start() {
 jettyServer = new Server();
 //We can use Contexts etc if we have many urls to handle. For one url,
 //specifying a handler directly is the most efficient.
 HttpConfiguration httpConfiguration = new HttpConfiguration();
 ServerConnector connector = new ServerConnector(jettyServer,
   new HttpConnectionFactory(httpConfiguration));
 connector.setReuseAddress(true);
 connector.setPort(port);
 jettyServer.addConnector(connector);
 jettyServer.setHandler(new HTTPMetricsHandler());
 try {
  jettyServer.start();
  while (!jettyServer.isStarted()) {
   Thread.sleep(500);
  }
 } catch (Exception ex) {
  LOG.error("Error starting Jetty. JSON Metrics may not be available.", ex);
 }
}

this.httpServer = new Server();
httpServer.setHandler(new HandlerCollection(true));
ServerConnector connector = null;
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSecureScheme(HTTPS);
httpConfig.setSecurePort(port);
 SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setCertAlias(sslConfig.getAlias());
 sslContextFactory.setNeedClientAuth(sslConfig.isRequireAuth());
  logger.debug(sslContextFactory.dump());
 httpConfig.addCustomizer(new SecureRequestCustomizer());
 connector = new ServerConnector(httpServer,
   new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
   new HttpConnectionFactory(httpConfig));
 connector.setPort(port);
httpServer.setConnectors(new Connector[] {connector});

/** Jetty server with one connector/port. */
private static Server jettyServer(ServletContextHandler handler, int port) {
  Server server = new Server();
  HttpConnectionFactory f1 = new HttpConnectionFactory();
  // Some people do try very large operations ... really, should use POST.
  f1.getHttpConfiguration().setRequestHeaderSize(512 * 1024);
  f1.getHttpConfiguration().setOutputBufferSize(1024 * 1024);
  // Do not add "Server: Jetty(....) when not a development system.
  if ( ! Fuseki.outputJettyServerHeader )
    f1.getHttpConfiguration().setSendServerVersion(false);
  ServerConnector connector = new ServerConnector(server, f1);
  connector.setPort(port);
  server.addConnector(connector);
  server.setHandler(handler);
  return server;
}

public void start() {
 if (useHttps) {
  server = new Server();
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setKeyStore(keyStore);
  sslContextFactory.setKeyStorePassword("password");
  sslContextFactory.setKeyManagerPassword("password");
  HttpConfiguration https = new HttpConfiguration();
  ServerConnector sslConnector =
    new ServerConnector(
      server,
      new SslConnectionFactory(sslContextFactory, "http/1.1"),
      new HttpConnectionFactory(https));
  sslConnector.setPort(httpPort);
  server.setConnectors(new Connector[] {sslConnector});
 } else {
  server = new Server(httpPort);
  ServerConnector connector =
    new ServerConnector(server, new HttpConnectionFactory(new HttpConfiguration()));
  connector.setPort(httpPort);
  server.setConnectors(new Connector[] {connector});

Server server = new Server();
HttpConfiguration https = new HttpConfiguration();
https.addCustomizer(new SecureRequestCustomizer());
SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStorePath(keyStorePath);
sslContextFactory.setKeyStorePassword("abc123");
sslContextFactory.setKeyManagerPassword("abc123");
ServerConnector sslConnector = new ServerConnector(
  server,
  new SslConnectionFactory(sslContextFactory, "http/1.1"),
  new HttpConnectionFactory(https)
);
sslConnector.setPort(0);
server.setConnectors(new Connector[]{sslConnector});
server.start();
      new Request(
        HttpMethod.GET,
        new URL(StringUtils.format("https://localhost:%d/", sslConnector.getLocalPort()))
      ),
      new StatusResponseHandler(StandardCharsets.UTF_8)

final SslContextFactory contextFactory = new SslContextFactory();
contextFactory.setNeedClientAuth(needClientAuth);
  contextFactory.setTrustStorePath(sslContextService.getTrustStoreFile());
  contextFactory.setTrustStoreType(sslContextService.getTrustStoreType());
  contextFactory.setTrustStorePassword(sslContextService.getTrustStorePassword());
final Server server = new Server(threadPool);
final HttpConfiguration httpConfiguration = new HttpConfiguration();
if (keystorePath == null) {
  connector = new ServerConnector(server, new HttpConnectionFactory(httpConfiguration));
} else {
  httpConfiguration.setSecureScheme("https");
  httpConfiguration.setSecurePort(port);
  httpConfiguration.addCustomizer(new SecureRequestCustomizer());
  connector = new ServerConnector(server, new SslConnectionFactory(contextFactory, "http/1.1"), new HttpConnectionFactory(httpConfiguration));
connector.setPort(port);
server.setConnectors(new Connector[] {connector});
  server.start();
} catch (Exception e) {
  shutdownHttpServer(server);

private void start() throws Exception {
  server = new Server();
  ServerConnector connector = new ServerConnector(server);
  server.addConnector(connector);
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setCertAlias("cruise");
  sslContextFactory.setKeyStoreResource(Resource.newClassPathResource("testdata/fake-server-keystore"));
  sslContextFactory.setKeyStorePassword("serverKeystorepa55w0rd");
  ServerConnector secureConnnector = new ServerConnector(server,
      new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()),
      new HttpConnectionFactory(new HttpConfiguration())
  );
  server.addConnector(secureConnnector);
  server.start();
  port = connector.getLocalPort();
  securePort = secureConnnector.getLocalPort();

private static void setupHttpServer(int httpPort, int httpsPort) throws Exception{
  QueuedThreadPool pool = new QueuedThreadPool();
  pool.setMaxThreads(500);
  LoklakInstallation.server = new Server(pool);
  LoklakInstallation.server.setStopAtShutdown(true);
    HttpConfiguration http_config = new HttpConfiguration();
    if(httpsMode.equals(HttpsMode.REDIRECT)) { //redirect
      http_config.addCustomizer(new SecureRequestCustomizer());
      http_config.setSecureScheme("https");
      http_config.setSecurePort(httpsPort);
    HttpConfiguration https_config = new HttpConfiguration();
    https_config.addCustomizer(new SecureRequestCustomizer());
    HttpConnectionFactory http1 = new HttpConnectionFactory(https_config);
    SslContextFactory sslContextFactory = new SslContextFactory();
    sslContextFactory.setKeyStore(keyStore);
    sslContextFactory.setKeyManagerPassword(keystoreManagerPass);
    SslConnectionFactory ssl = new SslConnectionFactory(sslContextFactory, "http/1.1");

private static Server createServer(Handler handler, int port, KeyStore keyStore, String keyPassword) throws Exception {
  Server server = new Server();
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setIncludeProtocols("TLSv1.2");
  sslContextFactory.setKeyStore(keyStore);
  sslContextFactory.setKeyManagerPassword(keyPassword);
  HttpConfiguration httpsConfig = new HttpConfiguration();
  httpsConfig.addCustomizer(new SecureRequestCustomizer());
  ServerConnector sslConnector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString()), new HttpConnectionFactory(httpsConfig));
  sslConnector.setPort(port);
  server.addConnector(sslConnector);
  server.setHandler(handler);
  return server;
}