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; }