Refine search
private Mono<Void> handleUnresolvedError(ServerWebExchange exchange, Throwable ex) { ServerHttpRequest request = exchange.getRequest(); ServerHttpResponse response = exchange.getResponse(); String logPrefix = exchange.getLogPrefix(); if (isDisconnectedClientError(ex)) { if (lostClientLogger.isTraceEnabled()) { lostClientLogger.trace(logPrefix + "Client went away", ex); } else if (lostClientLogger.isDebugEnabled()) { lostClientLogger.debug(logPrefix + "Client went away: " + ex + " (stacktrace at TRACE level for '" + DISCONNECTED_CLIENT_LOG_CATEGORY + "')"); } return Mono.empty(); } else if (response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR)) { logger.error(logPrefix + "500 Server Error for " + formatRequest(request), ex); return Mono.empty(); } else { // After the response is committed, propagate errors to the server.. logger.error(logPrefix + "Error [" + ex + "] for " + formatRequest(request) + ", but ServerHttpResponse already committed (" + response.getStatusCode() + ")"); return Mono.error(ex); } }
@Override public Mono<Void> render(@Nullable Map<String, ?> model, @Nullable MediaType contentType, ServerWebExchange exchange) { StringBuilder builder = new StringBuilder(); builder.append("name=").append(this.name).append('\n'); for (Map.Entry<String, ?> entry : model.entrySet()) { builder.append(entry.getKey()).append('=').append(entry.getValue()).append('\n'); } builder.setLength(builder.length() - 1); byte[] bytes = builder.toString().getBytes(StandardCharsets.UTF_8); ServerHttpResponse response = exchange.getResponse(); DataBuffer buffer = response.bufferFactory().wrap(bytes); response.getHeaders().setContentType(MediaType.TEXT_PLAIN); return response.writeWith(Mono.just(buffer)); } }
private static Mono<Void> respond(ServerWebExchange exchange, Map<String, String> parameters) { String wwwAuthenticate = computeWWWAuthenticateHeaderValue(parameters); exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN); exchange.getResponse().getHeaders().set(HttpHeaders.WWW_AUTHENTICATE, wwwAuthenticate); return exchange.getResponse().setComplete(); }
/** * Send a redirect back to the HTTP client. * @param targetUrl the target URL to redirect to * @param exchange current exchange */ protected Mono<Void> sendRedirect(String targetUrl, ServerWebExchange exchange) { String transformedUrl = (isRemoteHost(targetUrl) ? targetUrl : exchange.transformUrl(targetUrl)); ServerHttpResponse response = exchange.getResponse(); response.getHeaders().setLocation(URI.create(transformedUrl)); response.setStatusCode(getStatusCode()); return Mono.empty(); }
private void logResponse(ServerWebExchange exchange) { LogFormatUtils.traceDebug(logger, traceOn -> { HttpStatus status = exchange.getResponse().getStatusCode(); return exchange.getLogPrefix() + "Completed " + (status != null ? status : "200 OK") + (traceOn ? ", headers=" + formatHeaders(exchange.getResponse().getHeaders()) : ""); }); }
@Test public void preFlightRequestWithCorsConfigurationSource() throws Exception { this.handlerMapping.setCorsConfigurationSource(new CustomCorsConfigurationSource()); String origin = "http://domain2.com"; ServerWebExchange exchange = createExchange(HttpMethod.OPTIONS, "/welcome.html", origin); Object actual = this.handlerMapping.getHandler(exchange).block(); assertNotNull(actual); assertNotSame(this.welcomeController, actual); assertEquals("http://domain2.com", exchange.getResponse().getHeaders() .getFirst(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN)); assertEquals("true", exchange.getResponse().getHeaders() .getFirst(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS)); }
@Test public void actualRequestWithOriginHeader() throws Exception { ServerWebExchange exchange = actualRequest(); this.processor.process(this.conf, exchange); ServerHttpResponse response = exchange.getResponse(); assertFalse(response.getHeaders().containsKey(ACCESS_CONTROL_ALLOW_ORIGIN)); assertThat(response.getHeaders().get(VARY), contains(ORIGIN, ACCESS_CONTROL_REQUEST_METHOD, ACCESS_CONTROL_REQUEST_HEADERS)); assertEquals(HttpStatus.FORBIDDEN, response.getStatusCode()); }
@Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { // NOTICE: nothing in "pre" filter stage as CLIENT_RESPONSE_CONN_ATTR is not added // until the NettyRoutingFilter is run return chain.filter(exchange).then(Mono.defer(() -> { Connection connection = exchange.getAttribute(CLIENT_RESPONSE_CONN_ATTR); if (connection == null) { return Mono.empty(); } log.trace("NettyWriteResponseFilter start"); ServerHttpResponse response = exchange.getResponse(); NettyDataBufferFactory factory = (NettyDataBufferFactory) response.bufferFactory(); //TODO: what if it's not netty final Flux<NettyDataBuffer> body = connection.inbound().receive() .retain() //TODO: needed? .map(factory::wrap); MediaType contentType = null; try { contentType = response.getHeaders().getContentType(); } catch (Exception e) { log.trace("invalid media type", e); } return (isStreamingMediaType(contentType) ? response.writeAndFlushWith(body.map(Flux::just)) : response.writeWith(body)); })); }
@Test public void adaptResponse() throws Exception { ResponseCookie cookie = ResponseCookie.from("custom-cookie", "c0").build(); TestHttpHandler handler = new TestHttpHandler(response -> { response.setStatusCode(HttpStatus.OK); response.getHeaders().put("custom-header", Arrays.asList("h0", "h1")); response.addCookie(cookie); return response.writeWith(Mono.just(toDataBuffer("Custom body"))); }); ClientHttpResponse response = new HttpHandlerConnector(handler) .connect(HttpMethod.GET, URI.create("/custom-path"), ReactiveHttpOutputMessage::setComplete) .block(Duration.ofSeconds(5)); assertEquals(HttpStatus.OK, response.getStatusCode()); HttpHeaders headers = response.getHeaders(); assertEquals(Arrays.asList("h0", "h1"), headers.get("custom-header")); assertEquals(cookie, response.getCookies().getFirst("custom-cookie")); assertEquals(Collections.singletonList("custom-cookie=c0"), headers.get(HttpHeaders.SET_COOKIE)); DataBuffer buffer = response.getBody().blockFirst(Duration.ZERO); assertEquals("Custom body", DataBufferTestUtils.dumpString(buffer, UTF_8)); }
@Override public Mono<Void> upgrade(ServerWebExchange exchange, WebSocketHandler handler, @Nullable String subProtocol, Supplier<HandshakeInfo> handshakeInfoFactory) { ServerHttpRequest request = exchange.getRequest(); Assert.isInstanceOf(AbstractServerHttpRequest.class, request); HttpServerExchange httpExchange = ((AbstractServerHttpRequest) request).getNativeRequest(); Set<String> protocols = (subProtocol != null ? Collections.singleton(subProtocol) : Collections.emptySet()); Hybi13Handshake handshake = new Hybi13Handshake(protocols, false); List<Handshake> handshakes = Collections.singletonList(handshake); HandshakeInfo handshakeInfo = handshakeInfoFactory.get(); DataBufferFactory bufferFactory = exchange.getResponse().bufferFactory(); try { DefaultCallback callback = new DefaultCallback(handshakeInfo, handler, bufferFactory); new WebSocketProtocolHandshakeHandler(handshakes, callback).handleRequest(httpExchange); } catch (Exception ex) { return Mono.error(ex); } return Mono.empty(); }
@Override public Mono<Resource> transform(ServerWebExchange exchange, Resource inputResource, ResourceTransformerChain chain) { return chain.transform(exchange, inputResource) .flatMap(outputResource -> { String name = outputResource.getFilename(); if (!this.fileExtension.equals(StringUtils.getFilenameExtension(name))) { return Mono.just(outputResource); } DataBufferFactory bufferFactory = exchange.getResponse().bufferFactory(); Flux<DataBuffer> flux = DataBufferUtils .read(outputResource, bufferFactory, StreamUtils.BUFFER_SIZE); return DataBufferUtils.join(flux) .flatMap(dataBuffer -> { CharBuffer charBuffer = DEFAULT_CHARSET.decode(dataBuffer.asByteBuffer()); DataBufferUtils.release(dataBuffer); String content = charBuffer.toString(); return transform(content, outputResource, chain, exchange); }); }); }
@Test public void adaptRequest() throws Exception { TestHttpHandler handler = new TestHttpHandler(response -> { response.setStatusCode(HttpStatus.OK); return response.setComplete(); }); new HttpHandlerConnector(handler).connect(HttpMethod.POST, URI.create("/custom-path"), request -> { request.getHeaders().put("custom-header", Arrays.asList("h0", "h1")); request.getCookies().add("custom-cookie", new HttpCookie("custom-cookie", "c0")); return request.writeWith(Mono.just(toDataBuffer("Custom body"))); }).block(Duration.ofSeconds(5)); MockServerHttpRequest request = (MockServerHttpRequest) handler.getSavedRequest(); assertEquals(HttpMethod.POST, request.getMethod()); assertEquals("/custom-path", request.getURI().toString()); HttpHeaders headers = request.getHeaders(); assertEquals(Arrays.asList("h0", "h1"), headers.get("custom-header")); assertEquals(new HttpCookie("custom-cookie", "c0"), request.getCookies().getFirst("custom-cookie")); assertEquals(Collections.singletonList("custom-cookie=c0"), headers.get(HttpHeaders.COOKIE)); DataBuffer buffer = request.getBody().blockFirst(Duration.ZERO); assertEquals("Custom body", DataBufferTestUtils.dumpString(buffer, UTF_8)); }
@Override public Mono<WebSession> getSession(ServerWebExchange exchange) { return Mono.defer(() -> retrieveSession(exchange) .switchIfEmpty(this.sessionStore.createWebSession()) .doOnNext(session -> exchange.getResponse().beforeCommit(() -> save(exchange, session)))); }
@Bean public SimpleUrlHandlerMapping handlerMapping() { return new SimpleUrlHandlerMapping() { { Map<String, Object> map = new HashMap<>(); map.put("/foo", (WebHandler) exchange -> exchange.getResponse().writeWith(Flux.just(asDataBuffer("foo")))); map.put("/bar", (WebHandler) exchange -> exchange.getResponse().writeWith(Flux.just(asDataBuffer("bar")))); map.put("/header", (WebHandler) exchange -> { exchange.getResponse().getHeaders().add("foo", "bar"); return Mono.empty(); }); setUrlMap(map); } }; }
@Before public void setup() { this.filter = new OAuth2AuthorizationRequestRedirectWebFilter(this.clientRepository); this.filter.setAuthorizationRequestRepository(this.authzRequestRepository); FilteringWebHandler webHandler = new FilteringWebHandler(e -> e.getResponse().setComplete(), Arrays.asList(this.filter)); this.client = WebTestClient.bindToWebHandler(webHandler).build(); when(this.clientRepository.findByRegistrationId(this.registration.getRegistrationId())).thenReturn( Mono.just(this.registration)); when(this.authzRequestRepository.saveAuthorizationRequest(any(), any())).thenReturn( Mono.empty()); }
Map<String, Object> model, @Nullable MediaType contentType, ServerWebExchange exchange) { return Mono.defer(() -> { ServerHttpResponse response = exchange.getResponse(); try { ScriptEngine engine = getEngine(); Locale locale = LocaleContextHolder.getLocale(exchange.getLocaleContext()); RenderingContext context = new RenderingContext( obtainApplicationContext(), locale, templateLoader, url); DataBuffer buffer = response.bufferFactory().allocateBuffer(bytes.length).write(bytes); return response.writeWith(Mono.just(buffer));
@Override public Mono<Void> render(@Nullable Map<String, ?> model, @Nullable MediaType mediaType, ServerWebExchange exchange) { ServerHttpResponse response = exchange.getResponse(); if (mediaType != null) { response.getHeaders().setContentType(mediaType); } model = new TreeMap<>(model); String value = this.name + ": " + model.toString(); ByteBuffer byteBuffer = ByteBuffer.wrap(value.getBytes(UTF_8)); DataBuffer dataBuffer = new DefaultDataBufferFactory().wrap(byteBuffer); return response.writeWith(Flux.just(dataBuffer)); } }
@Test public void testWebFilter() throws Exception { WebFilter filter = (exchange, chain) -> { DataBuffer buffer = new DefaultDataBufferFactory().allocateBuffer(); buffer.write("It works!".getBytes(StandardCharsets.UTF_8)); return exchange.getResponse().writeWith(Mono.just(buffer)); }; WebTestClient client = WebTestClient.bindToWebHandler(exchange -> Mono.empty()) .webFilter(filter) .build(); client.get().uri("/") .exchange() .expectStatus().isOk() .expectBody(String.class).isEqualTo("It works!"); }
@Test public void thrownExceptionBecomesErrorSignal() throws Exception { createWebHandler(new BadRequestExceptionHandler()).handle(this.exchange).block(); assertEquals(HttpStatus.BAD_REQUEST, this.exchange.getResponse().getStatusCode()); }
@Override protected WebHttpHandlerBuilder initHttpHandlerBuilder() { return WebHttpHandlerBuilder.webHandler(exchange -> { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); String text = exchange.getAttributes().toString(); DataBuffer buffer = factory.wrap(text.getBytes(StandardCharsets.UTF_8)); return exchange.getResponse().writeWith(Mono.just(buffer)); }); } }