/** * Construct a Jetty Server instance. */ public static Server jettyCreateServer(Integer port, String host, Integer httpsPort, Integer headerBufferSize, Boolean disableHttpBinding) { Server server = new Server(); if (httpsPort == null || httpsPort <= 0 || disableHttpBinding == null || disableHttpBinding == false) { HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setSendDateHeader(true); if (null != headerBufferSize) { httpConfig.setRequestHeaderSize(headerBufferSize); } ServerConnector httpConnector = new ServerConnector( server, new HttpConnectionFactory(httpConfig) ); httpConnector.setPort(ObjectReader.getInt(port, 80)); httpConnector.setIdleTimeout(200000); httpConnector.setHost(host); server.addConnector(httpConnector); } return server; }
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; }
/** * Create a channel connector for "http/https" requests */ Connector createChannelConnector(int queueSize, Builder b) { ServerConnector connector; final HttpConfiguration conf = new HttpConfiguration(); conf.setRequestHeaderSize(1024*64); final HttpConnectionFactory http = new HttpConnectionFactory(conf); if (!b.useSSL) { connector = new ServerConnector(webServer, http); } else { SslContextFactory sslContextFactory = new SslContextFactory(); sslContextFactory.setKeyStorePath(b.keyStorePath); Set<String> excludedSSLProtocols = Sets.newHashSet( Splitter.on(",").trimResults().omitEmptyStrings().split( Strings.nullToEmpty(b.conf.getVar(ConfVars.HIVE_SSL_PROTOCOL_BLACKLIST)))); sslContextFactory.addExcludeProtocols(excludedSSLProtocols.toArray( new String[excludedSSLProtocols.size()])); sslContextFactory.setKeyStorePassword(b.keyStorePassword); connector = new ServerConnector(webServer, sslContextFactory, http); } connector.setAcceptQueueSize(queueSize); connector.setReuseAddress(true); connector.setHost(b.host); connector.setPort(b.port); return connector; }
httpConfig.setRequestHeaderSize(requestHeaderSize); httpConfig.setResponseHeaderSize(responseHeaderSize); httpConfig.setSendServerVersion(false);
private void configureConnectors(final Server server) throws ServerConfigurationException { // create the http configuration final HttpConfiguration httpConfiguration = new HttpConfiguration(); final int headerSize = DataUnit.parseDataSize(props.getWebMaxHeaderSize(), DataUnit.B).intValue(); httpConfiguration.setRequestHeaderSize(headerSize); httpConfiguration.setResponseHeaderSize(headerSize); // Check if both HTTP and HTTPS connectors are configured and fail if both are configured if (bothHttpAndHttpsConnectorsConfigured(props)) { logger.error("NiFi only supports one mode of HTTP or HTTPS operation, not both simultaneously. " + "Check the nifi.properties file and ensure that either the HTTP hostname and port or the HTTPS hostname and port are empty"); startUpFailure(new IllegalStateException("Only one of the HTTP and HTTPS connectors can be configured at one time")); } if (props.getSslPort() != null) { configureHttpsConnector(server, httpConfiguration); } else if (props.getPort() != null) { configureHttpConnector(server, httpConfiguration); } else { logger.error("Neither the HTTP nor HTTPS connector was configured in nifi.properties"); startUpFailure(new IllegalStateException("Must configure HTTP or HTTPS connector")); } }
httpConfig.setHeaderCacheSize(DEFAULT_MAX_HEADER_SIZE); httpConfig.setResponseHeaderSize(DEFAULT_MAX_HEADER_SIZE); httpConfig.setRequestHeaderSize(DEFAULT_MAX_HEADER_SIZE);
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);
httpsConfig.addCustomizer(new SecureRequestCustomizer()); if (null != headerBufferSize) { httpsConfig.setRequestHeaderSize(headerBufferSize);
int responseHeaderSize = hiveConf.getIntVar(ConfVars.HIVE_SERVER2_THRIFT_HTTP_RESPONSE_HEADER_SIZE); conf.setRequestHeaderSize(requestHeaderSize); conf.setResponseHeaderSize(responseHeaderSize); final HttpConnectionFactory http = new HttpConnectionFactory(conf) {
protected HttpConfiguration buildHttpConfiguration() { final HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setHeaderCacheSize((int) headerCacheSize.toBytes()); httpConfig.setOutputBufferSize((int) outputBufferSize.toBytes()); httpConfig.setRequestHeaderSize((int) maxRequestHeaderSize.toBytes()); httpConfig.setResponseHeaderSize((int) maxResponseHeaderSize.toBytes()); httpConfig.setSendDateHeader(useDateHeader); httpConfig.setSendServerVersion(useServerHeader); httpConfig.setMinResponseDataRate(minResponseDataPerSecond.toBytes()); httpConfig.setMinRequestDataRate(minRequestDataPerSecond.toBytes()); if (useForwardedHeaders) { httpConfig.addCustomizer(new ForwardedRequestCustomizer()); } return httpConfig; }
log.info("Creating http connector with port [%d]", node.getPlaintextPort()); HttpConfiguration httpConfiguration = new HttpConfiguration(); httpConfiguration.setRequestHeaderSize(config.getMaxRequestHeaderSize()); final ServerConnector connector = new ServerConnector(server, new HttpConnectionFactory(httpConfiguration)); if (node.isBindOnHost()) { httpsConfiguration.setSecurePort(node.getTlsPort()); httpsConfiguration.addCustomizer(new SecureRequestCustomizer()); httpsConfiguration.setRequestHeaderSize(config.getMaxRequestHeaderSize()); final ServerConnector connector = new ServerConnector( server,
private void configureProxiedConnector(HttpConfiguration httpConfig) { // Check to see if we are deployed behind a proxy // Refer to http://eclipse.org/jetty/documentation/current/configuring-connectors.html if (isXFFEnabled()) { ForwardedRequestCustomizer customizer = new ForwardedRequestCustomizer(); // default: "X-Forwarded-For" String forwardedForHeader = getXFFHeader(); if (forwardedForHeader != null) { customizer.setForwardedForHeader(forwardedForHeader); } // default: "X-Forwarded-Server" String forwardedServerHeader = getXFFServerHeader(); if (forwardedServerHeader != null) { customizer.setForwardedServerHeader(forwardedServerHeader); } // default: "X-Forwarded-Host" String forwardedHostHeader = getXFFHostHeader(); if (forwardedHostHeader != null) { customizer.setForwardedHostHeader(forwardedHostHeader); } // default: none String hostName = getXFFHostName(); if (hostName != null) { customizer.setHostHeader(hostName); } httpConfig.addCustomizer(customizer); } httpConfig.setRequestHeaderSize(JiveGlobals.getIntProperty(HTTP_BIND_REQUEST_HEADER_SIZE, HTTP_BIND_REQUEST_HEADER_SIZE_DEFAULT)); }
http_config.setRequestHeaderSize(65536); http_config.setResponseHeaderSize(65536); connector.addConnectionFactory(new HttpConnectionFactory(http_config));
httpConfig.setSecurePort(httpsPort); httpConfig.setOutputBufferSize(32768); httpConfig.setRequestHeaderSize(8192); httpConfig.setResponseHeaderSize(8192); httpConfig.setSendServerVersion(false);
public static void main(String[] args) throws Exception { Server server = new Server(); server.setHandler(new DefaultHandler()); // 404s for everything except favicon.ico HttpConfiguration config = new HttpConfiguration(); config.setRequestHeaderSize(65535); ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(config)); http.setPort(8080); server.setConnectors(new Connector[] {http}); server.start(); server.join(); }
protected ServerConnector getServerConnector() { HttpConnectionFactory factory = new HttpConnectionFactory(); factory.getHttpConfiguration().setRequestHeaderSize(maxAllowedHeaderSize); if (null == sslFactory) { return new ServerConnector(server, factory); } return new ServerConnector(server, AbstractConnectionFactory.getFactories(sslFactory, factory)); }
protected HttpConfiguration createHttpConfig(JettySettings jettySettings) { HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setRequestHeaderSize( jettySettings.getRequestHeaderSize().or(8192) ); httpConfig.setSendDateHeader(false); return httpConfig; }
/** HTTP configuration with setting for Fuseki workload. No "secure" settings. */ private static HttpConfiguration httpConfiguration() { HttpConfiguration http_config = new HttpConfiguration(); // Some people do try very large operations ... really, should use POST. http_config.setRequestHeaderSize(512 * 1024); http_config.setOutputBufferSize(1024 * 1024); // http_config.setResponseHeaderSize(8192); http_config.setSendServerVersion(false); return http_config; } }
/** HTTP configuration with setting for Fuseki workload. No "secure" settings. */ private static HttpConfiguration httpConfiguration() { HttpConfiguration http_config = new HttpConfiguration(); // Some people do try very large operations ... really, should use POST. http_config.setRequestHeaderSize(512 * 1024); http_config.setOutputBufferSize(1024 * 1024); // http_config.setResponseHeaderSize(8192); http_config.setSendServerVersion(false); return http_config; } }
private void configureHttpConnectionFactory(HttpConnectionFactory connFactory) { HttpConfiguration config = connFactory.getHttpConfiguration(); config.setRequestHeaderSize(this.config.getHeaderSize()); config.setResponseHeaderSize(this.config.getHeaderSize()); config.setOutputBufferSize(this.config.getResponseBufferSize()); // HTTP/1.1 requires Date header if possible (it is) config.setSendDateHeader(true); config.setSendServerVersion(this.config.isSendServerHeader()); config.setSendXPoweredBy(this.config.isSendServerHeader()); connFactory.setInputBufferSize(this.config.getRequestBufferSize()); }