case "compressionSupported": if (member.getValue() instanceof Boolean) { obj.setCompressionSupported((Boolean)member.getValue());
public void setUp() throws Exception { super.setUp(); client = vertx.createHttpClient(createHttp2ClientOptions().setTryUseCompression(true)); clientraw = vertx.createHttpClient(createHttp2ClientOptions().setTryUseCompression(false)); // server = vertx.createHttpServer(); serverWithMinCompressionLevel = vertx.createHttpServer( createHttp2ServerOptions(DEFAULT_HTTP_PORT - 1, DEFAULT_HTTP_HOST) .setCompressionSupported(true) .setCompressionLevel(1)); serverWithMaxCompressionLevel = vertx.createHttpServer( createHttp2ServerOptions(DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST) .setCompressionSupported(true) .setCompressionLevel(9)); }
public void setUp() throws Exception { super.setUp(); client = vertx.createHttpClient(new HttpClientOptions().setTryUseCompression(true)); clientraw = vertx.createHttpClient(new HttpClientOptions().setTryUseCompression(false)); HttpServerOptions serverOpts = new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setCompressionSupported(true); // server = vertx.createHttpServer(); serverWithMinCompressionLevel = vertx.createHttpServer(serverOpts.setPort(DEFAULT_HTTP_PORT - 1).setCompressionLevel(1)); serverWithMaxCompressionLevel = vertx.createHttpServer(serverOpts.setPort(DEFAULT_HTTP_PORT + 1).setCompressionLevel(9)); }
@Test public void testCompressedResponseWithConnectionCloseAndNoCompressionHeader() throws Exception { Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(2048)); server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setHost(DEFAULT_HTTP_HOST) .setCompressionSupported(true)); server.requestHandler(req -> { req.response().end(expected); }); startServer(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(expected, buff); complete(); }); })).putHeader("Connection", "close") .exceptionHandler(this::fail) .end(); await(); }
options.setHost(host); options.setAcceptBacklog(acceptBacklog); options.setCompressionSupported(compressionSupported); options.setMaxWebsocketFrameSize(maxWebsocketFrameSize); options.setWebsocketSubProtocols(wsSubProtocol);
case "compressionSupported": if (member.getValue() instanceof Boolean) { obj.setCompressionSupported((Boolean)member.getValue());
public void setUp() throws Exception { super.setUp(); client = vertx.createHttpClient(createHttp2ClientOptions().setTryUseCompression(true)); clientraw = vertx.createHttpClient(createHttp2ClientOptions().setTryUseCompression(false)); // server = vertx.createHttpServer(); serverWithMinCompressionLevel = vertx.createHttpServer( createHttp2ServerOptions(DEFAULT_HTTP_PORT - 1, DEFAULT_HTTP_HOST) .setCompressionSupported(true) .setCompressionLevel(1)); serverWithMaxCompressionLevel = vertx.createHttpServer( createHttp2ServerOptions(DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST) .setCompressionSupported(true) .setCompressionLevel(9)); }
@Override public HttpTermOptions setCompressionSupported(boolean compressionSupported) { return (HttpTermOptions) super.setCompressionSupported(compressionSupported); }
private void testSkipCompression(StaticHandler staticHandler, List<String> uris, List<String> expectedContentEncodings) throws Exception { server.close(); server = vertx.createHttpServer(getHttpServerOptions().setCompressionSupported(true)); router = Router.router(vertx); router.route().handler(staticHandler); CountDownLatch serverReady = new CountDownLatch(1); server.requestHandler(router).listen(onSuccess(s -> serverReady.countDown())); awaitLatch(serverReady); List<String> contentEncodings = Collections.synchronizedList(new ArrayList<>()); for (String uri : uris) { CountDownLatch responseReceived = new CountDownLatch(1); client.get(uri, onSuccess(resp -> { assertEquals(200, resp.statusCode()); contentEncodings.add(resp.getHeader(HttpHeaders.CONTENT_ENCODING)); responseReceived.countDown(); })) .putHeader(HttpHeaders.ACCEPT_ENCODING, String.join(", ", "gzip", "jpg", "jpeg", "png")) .end(); awaitLatch(responseReceived); } assertEquals(expectedContentEncodings, contentEncodings); }
public void setUp() throws Exception { super.setUp(); client = vertx.createHttpClient(new HttpClientOptions().setTryUseCompression(true)); clientraw = vertx.createHttpClient(new HttpClientOptions().setTryUseCompression(false)); HttpServerOptions serverOpts = new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setCompressionSupported(true); // server = vertx.createHttpServer(); serverWithMinCompressionLevel = vertx.createHttpServer(serverOpts.setPort(DEFAULT_HTTP_PORT - 1).setCompressionLevel(1)); serverWithMaxCompressionLevel = vertx.createHttpServer(serverOpts.setPort(DEFAULT_HTTP_PORT + 1).setCompressionLevel(9)); }
assertEquals(options, options.setCompressionSupported(true)); assertTrue(options.isCompressionSupported());
@Test public void testCompressedResponseWithConnectionCloseAndNoCompressionHeader() throws Exception { Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(2048)); server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setHost(DEFAULT_HTTP_HOST) .setCompressionSupported(true)); server.requestHandler(req -> { req.response().end(expected); }); startServer(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> { resp.bodyHandler(buff -> { assertEquals(expected, buff); complete(); }); }).putHeader("Connection", "close") .exceptionHandler(this::fail) .end(); await(); }
private HttpServerOptions createDefaultHttpServerOptions() { HttpServerOptions serverOptions = new HttpServerOptions(); serverOptions.setUsePooledBuffers(true); serverOptions.setIdleTimeout(TransportConfig.getConnectionIdleTimeoutInSeconds()); serverOptions.setCompressionSupported(TransportConfig.getCompressed()); serverOptions.setMaxHeaderSize(TransportConfig.getMaxHeaderSize()); serverOptions.setMaxInitialLineLength(TransportConfig.getMaxInitialLineLength()); if (endpointObject.isHttp2Enabled()) { serverOptions.setUseAlpn(TransportConfig.getUseAlpn()) .setInitialSettings(new Http2Settings().setMaxConcurrentStreams(TransportConfig.getMaxConcurrentStreams())); } if (endpointObject.isSslEnabled()) { SSLOptionFactory factory = SSLOptionFactory.createSSLOptionFactory(SSL_KEY, null); SSLOption sslOption; if (factory == null) { sslOption = SSLOption.buildFromYaml(SSL_KEY); } else { sslOption = factory.createSSLOption(); } SSLCustom sslCustom = SSLCustom.createSSLCustom(sslOption.getSslCustomClass()); VertxTLSBuilder.buildNetServerOptions(sslOption, sslCustom, serverOptions); } return serverOptions; } }
options.setCompressionSupported(httpServerConfiguration.isCompressionSupported()); options.setIdleTimeout(httpServerConfiguration.getIdleTimeout()); options.setTcpKeepAlive(httpServerConfiguration.isTcpKeepAlive());
options.setHost(host); options.setAcceptBacklog(acceptBacklog); options.setCompressionSupported(compressionSupported); options.setMaxWebsocketFrameSize(maxWebsocketFrameSize); options.setWebsocketSubProtocols(wsSubProtocol);
@Override public void start(Future<Void> startFuture) { // deploy the web server HttpServerOptions options = new HttpServerOptions() .setCompressionSupported(true); HttpServer server = vertx.createHttpServer(options); server.requestHandler(this::onRequest); server.listenObservable(8080) // listen on port 8080 .subscribe(v -> startFuture.complete(), startFuture::fail); }
private void configureHttpServer(VertxContext vertxContext, Future<HttpServerOptions> future) { HttpServerOptions httpServerOptions = new HttpServerOptions(); httpServerOptions.setPort(vertxContext.config().getInteger(HTTP_PORT_KEY, DEFAULT_PORT)); ServiceLoader<HttpServerConfigurator> configurators = ServiceLoader.load(HttpServerConfigurator.class); configurators.forEach(c -> c.configureHttpServer(vertxContext, httpServerOptions)); httpServerOptions.setCompressionSupported(true); future.complete(httpServerOptions); } }
private static Observable<HttpServer> setupMockEndpoint() { JsonObject config = vertx.getOrCreateContext().config(); String host = config.getString(ConfigConstants.HOST, ConfigConstants.DEFAULT_HOST); int port = config.getInteger(ConfigConstants.PORT, ConfigConstants.DEFAULT_PORT); HttpServerOptions serverOptions = new HttpServerOptions().setCompressionSupported(true); HttpServer server = vertxCore.createHttpServer(serverOptions); ObservableFuture<HttpServer> observable = RxHelper.observableFuture(); server.requestHandler(getStoreEndpointRouter()::accept).listen(port, host, observable.toHandler()); return observable; }
protected HttpServerOptions createServerOptions() { // Setup the http server options HttpServerOptions serverOptions = new HttpServerOptions() .setHost(getHost()) .setPort(getPort()) .setAcceptBacklog(getAcceptBacklog()) // Performance tweak .setCompressionSupported(getCompressionSupported()); // Enable https if (getSSL()) { serverOptions.setSsl(true); } if (getKeyStoreOptions() != null) { serverOptions.setKeyStoreOptions(getKeyStoreOptions()); } Integer receiveBufferSize = getReceiveBufferSize(); if (receiveBufferSize != null && receiveBufferSize > 0) { // TODO: This doesn't seem to actually affect buffer size for dataHandler. Is this being used correctly or is it a Vertx bug? serverOptions.setReceiveBufferSize(receiveBufferSize); } return serverOptions; }
assertEquals(options, options.setCompressionSupported(true)); assertTrue(options.isCompressionSupported());