@Override protected boolean matchesSafely(LiveHttpResponse response) { return response.status() == status; } }
@Override public boolean matchesSafely(LiveHttpResponse request) { return Objects.equals(status, request.status()); }
@Override protected void describeMismatchSafely(LiveHttpResponse response, Description mismatchDescription) { mismatchDescription.appendText("status with value of ").appendValue(response.status()); }
private void recordStatusCode(StatusRecordingChain chain, LiveHttpResponse response) { boolean isError = response.status().code() >= BAD_REQUEST.code(); boolean fromPlugin = response.status() != chain.upstreamStatus; if (isError && fromPlugin) { errorStatusMetrics.get(response.status()).mark(); if (response.status().equals(INTERNAL_SERVER_ERROR)) { errors.mark(); } } }
private static boolean isBodilessResponse(LiveHttpResponse response) { int status = response.status().code(); return status == 204 || status == 304 || status / 100 == 1; }
@Override public void proxyWriteFailure(LiveHttpRequest request, LiveHttpResponse response, Throwable cause) { incrementExceptionCounter(cause, response.status()); }
@Override public void proxyingFailure(LiveHttpRequest request, LiveHttpResponse response, Throwable cause) { incrementExceptionCounter(cause, response.status()); }
private State handleChannelException(ChannelHandlerContext ctx, Throwable cause) { Throwable sslException = sslException(cause); if (sslException != null) { if (ctx.channel().isActive()) { ctx.channel().close(); } LOGGER.info("SSL handshake failure from incoming connection " + "cause=\"{}\", " + "serverAddress={}, " + "clientAddress={}", new Object[]{sslException.getMessage(), ctx.channel().localAddress(), ctx.channel().remoteAddress()}); return TERMINATED; } if (!isIoException(cause)) { LiveHttpResponse response = exceptionToResponse(cause, ongoingRequest); httpErrorStatusListener.proxyErrorOccurred(response.status(), cause); if (ctx.channel().isActive()) { respondAndClose(ctx, response); } } return TERMINATED; }
/** * Creates a new {@link Builder} object from a response code and a content byte array. * * @param response a streaming HTTP response instance * @param body a HTTP message body */ public Builder(LiveHttpResponse response, byte[] body) { this.status = response.status(); this.version = response.version(); this.headers = response.headers().newBuilder(); this.body = body; }
private State onResponseSentAfterClientClosed(ChannelHandlerContext ctx) { statsSink.onComplete(ongoingRequest.id(), ongoingResponse.status().code()); tracker.endTrack(ongoingRequest); ongoingRequest = null; ctx.close(); return TERMINATED; }
/** * Creates a new {@link Builder} object from an existing {@link LiveHttpResponse} object. * Similar to {@link this.newBuilder} method. * * @param response a response object for which the builder is based on */ public Builder(LiveHttpResponse response) { this.status = response.status(); this.version = response.version(); this.headers = response.headers().newBuilder(); this.body = response.body(); }
private static Info information(LiveHttpResponse response, boolean longFormatEnabled) { Info info = new Info().add("status", response.status()); if (longFormatEnabled) { info.add("headers", response.headers()); } return info; }
@Override public Eventual<LiveHttpResponse> proceed(LiveHttpRequest request) { try { return new Eventual<>( toPublisher(toObservable(chain.proceed(request)) .doOnNext(response -> upstreamStatus = response.status()) .doOnError(error -> upstreamException = true))); } catch (Throwable e) { upstreamException = true; throw propagate(e); } } }
@Test public void createsResponseWithMinimalInformation() throws Exception { LiveHttpResponse response = response() .status(BAD_GATEWAY) .version(HTTP_1_0) .build(); assertThat(response.status(), is(BAD_GATEWAY)); assertThat(response.version(), is(HTTP_1_0)); assertThat(response.cookies(), is(emptyIterable())); assertThat(response.headers(), is(emptyIterable())); assertThat(bytesToString(response.body()), is("")); }
@Test public void failsIfRequestMethodIsNotSupported() throws Exception { HttpHandler handler = mock(HttpHandler.class); HttpMethodFilteringHandler post = new HttpMethodFilteringHandler(GET, handler); LiveHttpRequest request = post("/some-uri").build(); LiveHttpResponse response = Mono.from(post.handle(request, HttpInterceptorContext.create())).block(); assertThat(response.status(), is(METHOD_NOT_ALLOWED)); } }
private State onResponseSent(ChannelHandlerContext ctx) { statsSink.onComplete(ongoingRequest.id(), ongoingResponse.status().code()); tracker.endTrack(ongoingRequest); if (ongoingRequest.keepAlive()) { ongoingRequest = null; ongoingResponse = null; if (prematureRequest != null) { eventProcessor.submit(new RequestReceivedEvent(prematureRequest, ctx)); prematureRequest = null; } return ACCEPTING_REQUESTS; } else { ongoingRequest = null; ctx.close(); return TERMINATED; } }
@Test public void transformsStatus() { LiveHttpResponse response = response(OK).build() .newBuilder() .status(MOVED_PERMANENTLY) .build(); assertEquals(response.status(), MOVED_PERMANENTLY); }
public HttpResponse toNettyResponse(LiveHttpResponse httpResponse) { io.netty.handler.codec.http.HttpVersion version = toNettyVersion(httpResponse.version()); HttpResponseStatus httpResponseStatus = HttpResponseStatus.valueOf(httpResponse.status().code()); DefaultHttpResponse nettyResponse = new DefaultHttpResponse(version, httpResponseStatus, false); httpResponse.headers().forEach(httpHeader -> nettyResponse.headers().add(httpHeader.name(), httpHeader.value())); return nettyResponse; }
@Test public void convertsToStreamingHttpResponse() throws Exception { HttpResponse response = response(CREATED) .version(HTTP_1_1) .header("HeaderName", "HeaderValue") .cookies(responseCookie("CookieName", "CookieValue").build()) .body("message content", UTF_8) .build(); LiveHttpResponse streaming = response.stream(); assertThat(streaming.version(), is(HTTP_1_1)); assertThat(streaming.status(), is(CREATED)); assertThat(streaming.headers(), containsInAnyOrder( header("Content-Length", "15"), header("HeaderName", "HeaderValue"), header("Set-Cookie", "CookieName=CookieValue") )); assertThat(streaming.cookies(), contains(responseCookie("CookieName", "CookieValue").build())); StepVerifier.create(streaming.aggregate(0x100000).map(it -> it.bodyAs(UTF_8))) .expectNext("message content") .verifyComplete(); }