@Test public void shouldSetupHttpConnectionFactory() { ServerConnector connector = (ServerConnector) sslSocketConnector.getConnector(); Collection<ConnectionFactory> connectionFactories = connector.getConnectionFactories(); HttpConnectionFactory httpConnectionFactory = getHttpConnectionFactory(connectionFactories); assertThat(httpConnectionFactory.getHttpConfiguration().getOutputBufferSize(), is(100)); assertThat(httpConnectionFactory.getHttpConfiguration().getCustomizers().size(), is(2)); assertThat(httpConnectionFactory.getHttpConfiguration().getCustomizers().get(0), instanceOf(SecureRequestCustomizer.class)); assertThat(httpConnectionFactory.getHttpConfiguration().getCustomizers().get(1), instanceOf(ForwardedRequestCustomizer.class)); }
@Before public void setUp() { SystemEnvironment systemEnvironment = mock(SystemEnvironment.class); when(systemEnvironment.getServerPort()).thenReturn(1234); when(systemEnvironment.get(SystemEnvironment.RESPONSE_BUFFER_SIZE)).thenReturn(100); when(systemEnvironment.get(SystemEnvironment.IDLE_TIMEOUT)).thenReturn(200); when(systemEnvironment.getListenHost()).thenReturn("foo"); when(systemEnvironment.get(SystemEnvironment.GO_SSL_RENEGOTIATION_ALLOWED)).thenReturn(true); Jetty9Server server = new Jetty9Server(systemEnvironment, null); connector = (ServerConnector) new GoPlainSocketConnector(server, systemEnvironment).getConnector(); HttpConnectionFactory connectionFactory = (HttpConnectionFactory) connector.getDefaultConnectionFactory(); configuration = connectionFactory.getHttpConfiguration(); }
@Test public void shouldNotSendAServerHeaderForSecurityReasons() throws Exception { HttpConnectionFactory httpConnectionFactory = getHttpConnectionFactory(sslSocketConnector.getConnector().getConnectionFactories()); HttpConfiguration configuration = httpConnectionFactory.getHttpConfiguration(); assertThat(configuration.getSendServerVersion(), is(false)); }
/** 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; }
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 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)); }
/** Jetty server */ private static Server jettyServer(int port, boolean loopback) { Server server = new Server(); HttpConnectionFactory f1 = new HttpConnectionFactory(); //f1.getHttpConfiguration().setRequestHeaderSize(512 * 1024); //f1.getHttpConfiguration().setOutputBufferSize(1024 * 1024); f1.getHttpConfiguration().setSendServerVersion(false); ServerConnector connector = new ServerConnector(server, f1); connector.setPort(port); server.addConnector(connector); if ( loopback ) connector.setHost("localhost"); return server; } }
private LocalConnector createLocalConnector(Server server) { HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory(); httpConnectionFactory.getHttpConfiguration().setSendServerVersion(false); return new LocalConnector(server, null, null, null, -1, httpConnectionFactory); }
protected int startServer(ContextHandlerCollection contexts, Server jettyServer) throws Exception { ((HttpConnectionFactory) jettyServer.getConnectors()[0].getConnectionFactories().iterator().next()) .getHttpConfiguration().setRequestHeaderSize(30000); jettyServer.setHandler(contexts); if (injector.getInstance(GlobalConfigurationJsonStore.class).get().prometheus_enabled()) { registerPrometheus(); } jettyServer.start(); return ((ServerConnector) jettyServer.getConnectors()[0]).getLocalPort(); }
@Override public void customize(final Server server) { final Collection<HttpConnectionFactory> httpConnectionFactories = serverConnectionFactories(server, HttpConnectionFactory.class); httpConnectionFactories.forEach(httpConnectionFactory -> { final HttpConfiguration httpConfiguration = httpConnectionFactory.getHttpConfiguration(); httpConfiguration.addCustomizer(new ForwardedRequestCustomizer()); }); } }
@Override public void customizeConnector(ServerConnector connector) { if(sslProxy) { HttpConfiguration config = connector.getConnectionFactory(HttpConnectionFactory.class).getHttpConfiguration(); config.addCustomizer(new HttpConfiguration.Customizer() { @Override public void customize(Connector connector, HttpConfiguration channelConfig, Request request) { request.setScheme(URIUtil.HTTPS); request.setSecure(true); } }); } } }
@Override public void customize(final Server server) { final Collection<HttpConnectionFactory> httpConnectionFactories = serverConnectionFactories(server, HttpConnectionFactory.class); httpConnectionFactories.forEach(httpConnectionFactory -> { final HttpConfiguration httpConfiguration = httpConnectionFactory.getHttpConfiguration(); httpConfiguration.addCustomizer(new ForwardedRequestCustomizer()); }); } }
private static void configureConnectors(Server server) { for (Connector c : server.getConnectors()) { for (ConnectionFactory f : c.getConnectionFactories()) if (f instanceof HttpConnectionFactory) { final HttpConfiguration httpConf = ((HttpConnectionFactory) f).getHttpConfiguration(); httpConf.setSendServerVersion(false); httpConf.setSendDateHeader(false); } } } }
@Override public void removeCustomizers(Collection<Customizer> customizers) { Connector[] connectors = jettyServer.getConnectors(); for (Connector connector : connectors) { Collection<ConnectionFactory> connectionFactories = connector.getConnectionFactories(); for (ConnectionFactory connectionFactory : connectionFactories) { if (connectionFactory instanceof HttpConnectionFactory) { HttpConnectionFactory httpConnectionFactory = (HttpConnectionFactory) connectionFactory; HttpConfiguration httpConfiguration = httpConnectionFactory.getHttpConfiguration(); List<Customizer> httpConfigurationCustomizers = httpConfiguration.getCustomizers(); httpConfigurationCustomizers.removeAll(customizers); } } } }
@Override public void customize(final Server server) { final Collection<HttpConnectionFactory> httpConnectionFactories = serverConnectionFactories(server, HttpConnectionFactory.class); httpConnectionFactories.forEach(httpConnectionFactory -> { final HttpConfiguration httpConfiguration = httpConnectionFactory.getHttpConfiguration(); httpConfiguration.setSendServerVersion(false); httpConfiguration.setSendXPoweredBy(false); httpConfiguration.setSendDateHeader(false); }); } }
private boolean getSendServerVersion(Connector connector) { ConnectionFactory connFactory = connector.getConnectionFactory(HttpVersion.HTTP_1_1.asString()); if (connFactory == null) return false; if (connFactory instanceof HttpConnectionFactory) { HttpConfiguration httpConf = ((HttpConnectionFactory) connFactory).getHttpConfiguration(); if (httpConf != null) return httpConf.getSendServerVersion(); } return false; }
@Override public void customize(final Server server) { final Collection<HttpConnectionFactory> httpConnectionFactories = serverConnectionFactories(server, HttpConnectionFactory.class); httpConnectionFactories.forEach(httpConnectionFactory -> { final HttpConfiguration httpConfiguration = httpConnectionFactory.getHttpConfiguration(); httpConfiguration.setSendServerVersion(false); httpConfiguration.setSendXPoweredBy(false); httpConfiguration.setSendDateHeader(false); }); } }
@Override public void customizeConnector(ServerConnector connector) { connector.setPort(port); if(bindAddress != null) { connector.setHost(bindAddress); } HttpConfiguration config = connector.getConnectionFactory(HttpConnectionFactory.class).getHttpConfiguration(); if(forwarded) { config.addCustomizer(new ForwardedRequestCustomizer()); } if(requestHeaderSize != -1){ config.setRequestHeaderSize(requestHeaderSize); } }
private void configureForwardedRequestCustomizer() { JettyHTTPServerEngineFactory factory = new JettyHTTPServerEngineFactory(); JettyHTTPServerEngine engine = factory.retrieveJettyHTTPServerEngine(port); Iterator<ConnectionFactory> iter = engine.getConnector().getConnectionFactories().iterator(); while (iter.hasNext()) { HttpConnectionFactory f = (HttpConnectionFactory) iter.next(); f.getHttpConfiguration().addCustomizer(new ForwardedRequestCustomizer()); } }
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()); }