private static LiveHttpResponse removeHopByHopHeaders(LiveHttpResponse response) { LiveHttpResponse.Transformer newResponse = response.newBuilder(); response.header(CONNECTION).ifPresent(connection -> { for (String connectToken : connection.split(",")) { String header = connectToken.trim(); newResponse.removeHeader(header); } newResponse.removeHeader(CONNECTION); }); newResponse .removeHeader(KEEP_ALIVE) .removeHeader(PROXY_AUTHENTICATE) .removeHeader(PROXY_AUTHORIZATION) .removeHeader(TE) .removeHeader(TRAILER) .removeHeader(TRANSFER_ENCODING) .removeHeader(UPGRADE); return newResponse.build(); }
private LiveHttpResponse exceptionToResponse(Throwable exception, LiveHttpRequest request) { HttpResponseStatus status = status(exception instanceof PluginException ? exception.getCause() : exception); String message = status.code() >= 500 ? "Site temporarily unavailable." : status.description(); return responseEnhancer.enhance( LiveHttpResponse .response(status) .body(new ByteStream(Flux.just(new Buffer(message, UTF_8)))) .build() .newBuilder(), request) .header(CONTENT_LENGTH, message.getBytes(UTF_8).length) .build(); }
@Test public void newCookiesWithDuplicateNamesOverridePreviousOnes() { LiveHttpResponse r1 = response() .cookies(responseCookie("y", "y1").build()) .build(); LiveHttpResponse r2 = r1.newBuilder().addCookies( responseCookie("y", "y2").build()) .build(); assertThat(r2.cookies(), containsInAnyOrder(responseCookie("y", "y2").build())); }
private LiveHttpResponse.Transformer addInfoHeader(LiveHttpResponse.Transformer responseBuilder, LiveHttpRequest request) { return responseBuilder.header(styxInfoHeaderName, responseInfoFormat.format(request)); }
@Test public void transformerReplacesBody() { Buffer buf1 = new Buffer("chunk 1, ", UTF_8); Buffer buf2 = new Buffer("chunk 2.", UTF_8); LiveHttpResponse response1 = response(NO_CONTENT) .body(new ByteStream(Flux.just(buf1, buf2))) .build() .newBuilder() .body(body -> body.replaceWith(ByteStream.from("replacement", UTF_8))) .build(); HttpResponse response2 = Mono.from(response1.aggregate(100)).block(); assertEquals(response2.bodyAs(UTF_8), "replacement"); assertEquals(buf1.delegate().refCnt(), 0); assertEquals(buf2.delegate().refCnt(), 0); }
@Test public void transformsBody() throws ExecutionException, InterruptedException { Buffer buffer = new Buffer("I'm going to get removed.", UTF_8); LiveHttpResponse response = response(NO_CONTENT) .body(new ByteStream(Flux.just(buffer))) .build(); HttpResponse fullResponse = Mono.from(response.newBuilder() .body(ByteStream::drop) .build() .aggregate(1000)).block(); assertThat(fullResponse.body().length, is(0)); assertThat(buffer.delegate().refCnt(), is(0)); }
/** * Create a new enhanced response, based on an existing one. This is less efficient than * {@link #enhance(LiveHttpResponse.Transformer, LiveHttpRequest)} as it has to create a new builder * and build, but it suitable for cases where that would have to happen anyway. * * @param response response * @param request request * @return enhanced response */ default LiveHttpResponse enhance(LiveHttpResponse response, LiveHttpRequest request) { return enhance(response.newBuilder(), request).build(); } }
@Test public void shouldNotFailToRemoveNonExistentContentLength() { LiveHttpResponse response = response().build(); LiveHttpResponse chunkedResponse = response.newBuilder().setChunked().build(); assertThat(chunkedResponse.chunked(), is(true)); assertThat(chunkedResponse.header(CONTENT_LENGTH).isPresent(), is(false)); }
@Test public void removesCookies() { LiveHttpResponse r1 = response() .addCookies(responseCookie("x", "x1").build(), responseCookie("y", "y1").build()) .build(); LiveHttpResponse r2 = r1.newBuilder() .removeCookies("x") .removeCookies("foo") // ensure that trying to remove a non-existent cookie does not cause Exception .build(); assertThat(r2.cookies(), contains(responseCookie("y", "y1").build())); }
@Override public Eventual<LiveHttpResponse> intercept(LiveHttpRequest request, Chain chain) { LiveHttpRequest newRequest = request.newBuilder() .header(VIA, viaHeader(request)) .build(); return chain.proceed(newRequest) .map(response -> response.newBuilder() .header(VIA, viaHeader(response)) .build()); }
private LiveHttpResponse addStickySessionIdentifier(LiveHttpResponse httpResponse, Origin origin) { if (this.loadBalancer instanceof StickySessionLoadBalancingStrategy) { int maxAge = stickySessionConfig.stickySessionTimeoutSeconds(); return httpResponse.newBuilder() .addCookies(newStickySessionCookie(id, origin.id(), maxAge)) .build(); } else { return httpResponse; } }
@Test public void canRemoveAHeader() { Object headerValue = "b"; LiveHttpResponse response = response() .header("a", headerValue) .addHeader("c", headerValue) .build(); LiveHttpResponse shouldRemoveHeader = response.newBuilder() .removeHeader("c") .build(); assertThat(shouldRemoveHeader.headers(), contains(header("a", "b"))); }
private LiveHttpResponse removeRedundantContentLengthHeader(LiveHttpResponse response) { if (contentValidation && response.contentLength().isPresent() && response.chunked()) { return response.newBuilder() .removeHeader(CONTENT_LENGTH) .build(); } return response; }